X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=cd8d498d1fe226ac936b2dc71d0c0d2102c499b1;hb=e21ca4562ad6a6581423ec393a359704f620feea;hp=a455e40a1f5bd72d025d30d941460d91ded5dc2a;hpb=154fc1235e5f2be16af4cb9f61bdd160d3880452;p=pspp-builds.git diff --git a/src/data/variable.c b/src/data/variable.c index a455e40a..cd8d498d 100644 --- a/src/data/variable.c +++ b/src/data/variable.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 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 @@ -19,22 +19,23 @@ #include -#include "category.h" -#include "data-out.h" -#include "format.h" -#include "dictionary.h" -#include "identifier.h" -#include "missing-values.h" -#include "value-labels.h" -#include "vardict.h" +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include -#include +#include #include #include +#include "minmax.h" #include "xalloc.h" #include "gettext.h" @@ -44,7 +45,7 @@ struct variable { /* Dictionary information. */ - char name[VAR_NAME_LEN + 1]; /* Variable name. Mixed case. */ + char *name; /* Variable name. Mixed case. */ int width; /* 0 for numeric, otherwise string width. */ struct missing_values miss; /* Missing values. */ struct fmt_spec print; /* Default format for PRINT. */ @@ -61,7 +62,7 @@ struct variable bool leave; /* Leave value from case to case? */ /* Data for use by containing dictionary. */ - struct vardict_info vardict; + struct vardict_info *vardict; /* Used only for system and portable file input and output. See short-names.h. */ @@ -72,10 +73,8 @@ struct variable void *aux; void (*aux_dtor) (struct variable *); - /* Values of a categorical variable. Procedures need - vectors with binary entries, so any variable of type ALPHA will - have its values stored here. */ - struct cat_vals *obs_vals; + /* Custom attributes. */ + struct attrset attributes; }; /* Creates and returns a new variable with the given NAME and @@ -91,7 +90,8 @@ var_create (const char *name, int width) assert (width >= 0 && width <= MAX_STRING); v = xmalloc (sizeof *v); - v->vardict.dict_index = v->vardict.case_index = -1; + v->vardict = NULL; + v->name = NULL; var_set_name (v, name); v->width = width; mv_init (&v->miss, width); @@ -107,7 +107,7 @@ var_create (const char *name, int width) v->short_name_cnt = 0; v->aux = NULL; v->aux_dtor = NULL; - v->obs_vals = NULL; + attrset_init (&v->attributes); return v; } @@ -121,8 +121,7 @@ var_create (const char *name, int width) - The new variable is not added to OLD_VAR's dictionary by default. Use dict_clone_var, instead, to do that. - - - Auxiliary data and obs_vals are not copied. */ +*/ struct variable * var_clone (const struct variable *old_var) { @@ -138,6 +137,7 @@ var_clone (const struct variable *old_var) var_set_display_width (new_var, var_get_display_width (old_var)); var_set_alignment (new_var, var_get_alignment (old_var)); var_set_leave (new_var, var_get_leave (old_var)); + var_set_attributes (new_var, var_get_attributes (old_var)); return new_var; } @@ -151,11 +151,12 @@ var_destroy (struct variable *v) if (v != NULL) { assert (!var_has_vardict (v)); - cat_stored_values_destroy (v->obs_vals); + mv_destroy (&v->miss); var_clear_short_names (v); var_clear_aux (v); val_labs_destroy (v->val_labs); var_clear_label (v); + free (v->name); free (v); } } @@ -175,10 +176,11 @@ var_get_name (const struct variable *v) void var_set_name (struct variable *v, const char *name) { - assert (v->vardict.dict_index == -1); + assert (!var_has_vardict (v)); assert (var_is_plausible_name (name, false)); - str_copy_trunc (v->name, sizeof v->name, name); + free (v->name); + v->name = xstrdup (name); dict_var_changed (v); } @@ -191,8 +193,6 @@ var_is_valid_name (const char *name, bool issue_error) bool plausible; size_t length, i; - assert (name != NULL); - /* Note that strlen returns number of BYTES, not the number of CHARACTERS */ length = strlen (name); @@ -238,8 +238,6 @@ var_is_plausible_name (const char *name, bool issue_error) { size_t length; - assert (name != NULL); - /* Note that strlen returns number of BYTES, not the number of CHARACTERS */ length = strlen (name); @@ -292,7 +290,7 @@ hash_var_by_name (const void *v_, const void *aux UNUSED) { const struct variable *v = v_; - return hsh_hash_case_string (v->name); + return hash_case_string (v->name, 0); } /* A hsh_compare_func that orders pointers to variables A and B @@ -307,6 +305,20 @@ compare_var_ptrs_by_name (const void *a_, const void *b_, return strcasecmp (var_get_name (*a), var_get_name (*b)); } +/* A hsh_compare_func that orders pointers to variables A and B + by their dictionary indexes. */ +int +compare_var_ptrs_by_dict_index (const void *a_, const void *b_, + const void *aux UNUSED) +{ + struct variable *const *a = a_; + struct variable *const *b = b_; + size_t a_index = var_get_dict_index (*a); + size_t b_index = var_get_dict_index (*b); + + return a_index < b_index ? -1 : a_index > b_index; +} + /* A hsh_hash_func that hashes pointer to variable V based on its name. */ unsigned @@ -314,7 +326,7 @@ hash_var_ptr_by_name (const void *v_, const void *aux UNUSED) { struct variable *const *v = v_; - return hsh_hash_case_string (var_get_name (*v)); + return hash_case_string (var_get_name (*v), 0); } /* Returns the type of variable V. */ @@ -338,10 +350,16 @@ var_set_width (struct variable *v, int new_width) { const int old_width = v->width; + if (old_width == new_width) + return; + if (mv_is_resizable (&v->miss, new_width)) mv_resize (&v->miss, new_width); else - mv_init (&v->miss, new_width); + { + mv_destroy (&v->miss); + mv_init (&v->miss, new_width); + } if (v->val_labs != NULL) { @@ -358,15 +376,7 @@ var_set_width (struct variable *v, int new_width) fmt_resize (&v->write, new_width); v->width = new_width; - - { - const int old_val_count = value_cnt_from_width (old_width); - const int new_val_count = value_cnt_from_width (new_width); - - if ( old_val_count != new_val_count) - dict_var_resized (v, new_val_count - old_val_count); - } - + dict_var_resized (v, old_width); dict_var_changed (v); } @@ -384,30 +394,6 @@ var_is_alpha (const struct variable *v) { return var_get_type (v) == VAL_STRING; } - -/* Returns true if variable V is a short string variable, false - otherwise. */ -bool -var_is_short_string (const struct variable *v) -{ - return v->width > 0 && v->width <= MAX_SHORT_STRING; -} - -/* Returns true if variable V is a long string variable, false - otherwise. */ -bool -var_is_long_string (const struct variable *v) -{ - return v->width > MAX_SHORT_STRING; -} - -/* Returns the number of "union value"s need to store a value of - variable V. */ -size_t -var_get_value_cnt (const struct variable *v) -{ - return value_cnt_from_width (v->width); -} /* Returns variable V's missing values. */ const struct missing_values * @@ -426,11 +412,12 @@ var_set_missing_values (struct variable *v, const struct missing_values *miss) if (miss != NULL) { assert (mv_is_resizable (miss, v->width)); + mv_destroy (&v->miss); mv_copy (&v->miss, miss); mv_resize (&v->miss, v->width); } else - mv_init (&v->miss, v->width); + mv_clear (&v->miss); dict_var_changed (v); } @@ -472,7 +459,7 @@ var_is_num_missing (const struct variable *v, double d, enum mv_class class) S[] must contain exactly as many characters as V's width. V must be a string variable. */ bool -var_is_str_missing (const struct variable *v, const char s[], +var_is_str_missing (const struct variable *v, const uint8_t s[], enum mv_class class) { return mv_is_str_missing (&v->miss, s, class); @@ -517,31 +504,30 @@ var_set_value_labels (struct variable *v, const struct val_labs *vls) static void alloc_value_labels (struct variable *v) { - assert (!var_is_long_string (v)); if (v->val_labs == NULL) v->val_labs = val_labs_create (v->width); } /* Attempts to add a value label with the given VALUE and LABEL - to V. Returns true if successful, false if VALUE has an - existing label or if V is a long string variable. */ + to V. Returns true if successful, false otherwise (probably + due to an existing label). */ bool var_add_value_label (struct variable *v, const union value *value, const char *label) { alloc_value_labels (v); - return val_labs_add (v->val_labs, *value, label); + return val_labs_add (v->val_labs, value, label); } /* Adds or replaces a value label with the given VALUE and LABEL to V. - Has no effect if V is a long string variable. */ +*/ void var_replace_value_label (struct variable *v, const union value *value, const char *label) { alloc_value_labels (v); - val_labs_replace (v->val_labs, *value, label); + val_labs_replace (v->val_labs, value, label); } /* Removes V's value labels, if any. */ @@ -556,7 +542,7 @@ var_clear_value_labels (struct variable *v) const char * var_lookup_value_label (const struct variable *v, const union value *value) { - return val_labs_find (v->val_labs, *value); + return val_labs_find (v->val_labs, value); } /* Append STR with a string representing VALUE for variable V. @@ -571,14 +557,14 @@ var_append_value_name (const struct variable *v, const union value *value, const char *name = var_lookup_value_label (v, value); if (name == NULL) { - char *s = ds_put_uninit (str, v->print.w); - data_out (value, &v->print, s); + char *s = data_out (value, var_get_encoding (v), &v->print); + ds_put_cstr (str, s); + free (s); } else ds_put_cstr (str, name); } - /* Print and write formats. */ /* Returns V's print format specification. */ @@ -676,8 +662,8 @@ var_set_label (struct variable *v, const char *label) ss_truncate (&s, 255); if (!ss_is_empty (s)) v->label = ss_xstrdup (s); - dict_var_changed (v); } + dict_var_changed (v); } /* Removes any variable label from V. */ @@ -738,9 +724,15 @@ var_get_display_width (const struct variable *v) /* Sets V's display width to DISPLAY_WIDTH. */ void -var_set_display_width (struct variable *v, int display_width) +var_set_display_width (struct variable *v, int new_width) { - v->display_width = display_width; + int old_width = v->display_width; + + v->display_width = new_width; + + if ( old_width != new_width) + dict_var_display_width_changed (v); + dict_var_changed (v); } @@ -847,7 +839,6 @@ var_get_short_name (const struct variable *var, size_t idx) void var_set_short_name (struct variable *var, size_t idx, const char *short_name) { - assert (var != NULL); assert (short_name == NULL || var_is_plausible_name (short_name, false)); /* Clear old short name numbered IDX, if any. */ @@ -898,8 +889,8 @@ var_clear_short_names (struct variable *v) size_t var_get_dict_index (const struct variable *v) { - assert (v->vardict.dict_index != -1); - return v->vardict.dict_index; + assert (var_has_vardict (v)); + return vardict_get_dict_index (v->vardict); } /* Returns V's index within the case represented by its @@ -909,8 +900,8 @@ var_get_dict_index (const struct variable *v) size_t var_get_case_index (const struct variable *v) { - assert (v->vardict.case_index != -1); - return v->vardict.case_index; + assert (var_has_vardict (v)); + return vardict_get_case_index (v->vardict); } /* Returns V's auxiliary data, or a null pointer if none has been @@ -929,7 +920,7 @@ void * var_attach_aux (const struct variable *v_, void *aux, void (*aux_dtor) (struct variable *)) { - struct variable *v = (struct variable *) v_ ; /* cast away const */ + struct variable *v = CONST_CAST (struct variable *, v_); assert (v->aux == NULL); assert (aux != NULL); v->aux = aux; @@ -953,7 +944,6 @@ var_detach_aux (struct variable *v) void var_clear_aux (struct variable *v) { - assert (v != NULL); if (v->aux != NULL) { if (v->aux_dtor != NULL) @@ -971,62 +961,66 @@ var_dtor_free (struct variable *v) free (v->aux); } -/* Observed categorical values. */ - -/* Returns V's observed categorical values, - which V must have. */ -struct cat_vals * -var_get_obs_vals (const struct variable *v) +/* Returns variable V's attribute set. The caller may examine or + modify the attribute set, but must not destroy it. Destroying + V, or calling var_set_attributes() on V, will also destroy its + attribute set. */ +struct attrset * +var_get_attributes (const struct variable *v) { - assert (v->obs_vals != NULL); - return v->obs_vals; + return CONST_CAST (struct attrset *, &v->attributes); } -/* Sets V's observed categorical values to CAT_VALS. - V becomes the owner of CAT_VALS. */ +/* Replaces variable V's attributes set by a copy of ATTRS. */ void -var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals) +var_set_attributes (struct variable *v, const struct attrset *attrs) { - struct variable *v = (struct variable *) v_ ; /* cast away const */ - cat_stored_values_destroy (v->obs_vals); - v->obs_vals = cat_vals; + attrset_destroy (&v->attributes); + attrset_clone (&v->attributes, attrs); } -/* Returns true if V has observed categorical values, - false otherwise. */ +/* Returns true if V has any custom attributes, false if it has none. */ bool -var_has_obs_vals (const struct variable *v) +var_has_attributes (const struct variable *v) +{ + return attrset_count (&v->attributes) > 0; +} + +/* Returns the encoding of values of variable VAR. (This is actually a + property of the dictionary.) Returns null if no specific encoding has been + set. */ +const char * +var_get_encoding (const struct variable *var) { - return v->obs_vals != NULL; + return (var_has_vardict (var) + ? dict_get_encoding (vardict_get_dictionary (var->vardict)) + : NULL); } /* Returns V's vardict structure. */ -const struct vardict_info * +struct vardict_info * var_get_vardict (const struct variable *v) { - assert (var_has_vardict (v)); - return &v->vardict; + return CONST_CAST (struct vardict_info *, v->vardict); } /* Sets V's vardict data to VARDICT. */ void -var_set_vardict (struct variable *v, const struct vardict_info *vardict) +var_set_vardict (struct variable *v, struct vardict_info *vardict) { - assert (vardict->dict_index >= 0); - assert (vardict->case_index >= 0); - v->vardict = *vardict; + v->vardict = vardict; } /* Returns true if V has vardict data. */ bool var_has_vardict (const struct variable *v) { - return v->vardict.dict_index != -1; + return v->vardict != NULL; } /* Clears V's vardict data. */ void var_clear_vardict (struct variable *v) { - v->vardict.dict_index = v->vardict.case_index = -1; + v->vardict = NULL; }