X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fvariable.c;h=a60adcafcd8d25422f7be32d8f870059c2c028f3;hb=f15c854d8500105766b2f5666bb62b983ff24f88;hp=59f452217c1178ea95ac79264f4749e6256f1f51;hpb=6999c6d125665923b52ae15cbad83d06c92a8875;p=pspp-builds.git diff --git a/src/data/variable.c b/src/data/variable.c index 59f45221..a60adcaf 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 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,23 +19,26 @@ #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 +#include "minmax.h" +#include "xalloc.h" + #include "gettext.h" #define _(msgid) gettext (msgid) @@ -43,7 +46,7 @@ struct variable { /* Dictionary information. */ - char name[LONG_NAME_LEN + 1]; /* Variable name. Mixed case. */ + char name[VAR_NAME_LEN + 1]; /* 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. */ @@ -75,21 +78,10 @@ struct variable vectors with binary entries, so any variable of type ALPHA will have its values stored here. */ struct cat_vals *obs_vals; - }; - -/* Returns true if VAR_TYPE is a valid variable type. */ -bool -var_type_is_valid (enum var_type var_type) -{ - return var_type == VAR_NUMERIC || var_type == VAR_STRING; -} -/* Returns the variable type for the given width. */ -enum var_type -var_type_from_width (int width) -{ - return width != 0 ? VAR_STRING : VAR_NUMERIC; -} + /* Custom attributes. */ + struct attrset attributes; + }; /* Creates and returns a new variable with the given NAME and WIDTH and other fields initialized to default values. The @@ -99,6 +91,7 @@ struct variable * var_create (const char *name, int width) { struct variable *v; + enum val_type type; assert (width >= 0 && width <= MAX_STRING); @@ -108,21 +101,11 @@ var_create (const char *name, int width) v->width = width; mv_init (&v->miss, width); v->leave = var_must_leave (v); - if (var_is_numeric (v)) - { - v->print = fmt_for_output (FMT_F, 8, 2); - v->alignment = ALIGN_RIGHT; - v->display_width = 8; - v->measure = MEASURE_SCALE; - } - else - { - v->print = fmt_for_output (FMT_A, var_get_width (v), 0); - v->alignment = ALIGN_LEFT; - v->display_width = 8; - v->measure = MEASURE_NOMINAL; - } - v->write = v->print; + type = val_type_from_width (width); + v->alignment = var_default_alignment (type); + v->measure = var_default_measure (type); + v->display_width = var_default_display_width (width); + v->print = v->write = var_default_formats (width); v->val_labs = NULL; v->label = NULL; v->short_names = NULL; @@ -130,6 +113,7 @@ var_create (const char *name, int width) v->aux = NULL; v->aux_dtor = NULL; v->obs_vals = NULL; + attrset_init (&v->attributes); return v; } @@ -160,10 +144,32 @@ 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; } +/* Create a variable of the specified WIDTH to be used for + internal calculations only. The variable is assigned a unique + dictionary index and a case index of CASE_IDX. */ +struct variable * +var_create_internal (int case_idx, int width) +{ + struct variable *v = var_create ("$internal", width); + struct vardict_info vdi; + static int counter = INT_MAX / 2; + + vdi.dict = NULL; + vdi.case_index = case_idx; + vdi.dict_index = counter++; + if (counter == INT_MAX) + counter = INT_MAX / 2; + + var_set_vardict (v, &vdi); + + return v; +} + /* Destroys variable V. V must not belong to a dictionary. If it does, use dict_delete_var instead. */ @@ -172,8 +178,14 @@ var_destroy (struct variable *v) { if (v != NULL) { - assert (!var_has_vardict (v)); + if (var_has_vardict (v)) + { + const struct vardict_info *vdi = var_get_vardict (v); + assert (vdi->dict == NULL); + } + mv_destroy (&v->miss); cat_stored_values_destroy (v->obs_vals); + var_clear_short_names (v); var_clear_aux (v); val_labs_destroy (v->val_labs); var_clear_label (v); @@ -270,11 +282,11 @@ var_is_plausible_name (const char *name, bool issue_error) msg (SE, _("Variable name cannot be empty string.")); return false; } - else if (length > LONG_NAME_LEN) + else if (length > VAR_NAME_LEN) { if (issue_error) msg (SE, _("Variable name %s exceeds %d-character limit."), - name, (int) LONG_NAME_LEN); + name, (int) VAR_NAME_LEN); return false; } @@ -289,6 +301,13 @@ var_is_plausible_name (const char *name, bool issue_error) return true; } +/* Returns VAR's dictionary class. */ +enum dict_class +var_get_dict_class (const struct variable *var) +{ + return dict_class_from_id (var->name); +} + /* A hsh_compare_func that orders variables A and B by their names. */ int @@ -306,7 +325,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 @@ -321,6 +340,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 @@ -328,14 +361,14 @@ 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. */ -enum var_type +enum val_type var_get_type (const struct variable *v) { - return var_type_from_width (v->width); + return val_type_from_width (v->width); } /* Returns the width of variable V. */ @@ -345,16 +378,23 @@ var_get_width (const struct variable *v) return v->width; } -/* Sets the width of V to WIDTH. */ +/* Changes the width of V to NEW_WIDTH. + This function should be used cautiously. */ void 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) { @@ -371,15 +411,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); } @@ -387,7 +419,7 @@ var_set_width (struct variable *v, int new_width) bool var_is_numeric (const struct variable *v) { - return var_get_type (v) == VAR_NUMERIC; + return var_get_type (v) == VAL_NUMERIC; } /* Returns true if variable V is a string variable, false @@ -395,31 +427,7 @@ var_is_numeric (const struct variable *v) bool var_is_alpha (const struct variable *v) { - return var_get_type (v) == VAR_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); + return var_get_type (v) == VAL_STRING; } /* Returns variable V's missing values. */ @@ -439,11 +447,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); } @@ -519,7 +528,7 @@ var_set_value_labels (struct variable *v, const struct val_labs *vls) if (vls != NULL) { assert (val_labs_can_set_width (vls, v->width)); - v->val_labs = val_labs_copy (vls); + v->val_labs = val_labs_clone (vls); val_labs_set_width (v->val_labs, v->width); dict_var_changed (v); } @@ -530,32 +539,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. - V must not be a long string variable. */ + existing label or if V is a long string variable. */ 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. - V must not be a long string variable. */ + 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. */ @@ -570,24 +577,27 @@ 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); } -/* Get a string representing VALUE for variable V. - That is, if VALUE has a label, return that label, - otherwise format VALUE and return the formatted string. */ -const char * -var_get_value_name (const struct variable *v, const union value *value) +/* Append STR with a string representing VALUE for variable V. + That is, if VALUE has a label, append that label, + otherwise format VALUE and append the formatted string. + STR must be a pointer to an initialised struct string. +*/ +void +var_append_value_name (const struct variable *v, const union value *value, + struct string *str) { const char *name = var_lookup_value_label (v, value); if (name == NULL) { - static char buf[MAX_STRING + 1]; - data_out (value, &v->print, buf); - buf[v->print.w] = '\0'; - name = buf; + char *s = data_out (value, &v->print); + ds_put_cstr (str, s); + free (s); } - return name; + else + ds_put_cstr (str, name); } /* Print and write formats. */ @@ -600,8 +610,9 @@ var_get_print_format (const struct variable *v) } /* Sets V's print format specification to PRINT, which must be a - valid format specification for outputting a variable of V's - width. */ + valid format specification for a variable of V's width + (ordinarily an output format, but input formats are not + rejected). */ void var_set_print_format (struct variable *v, const struct fmt_spec *print) { @@ -618,8 +629,9 @@ var_get_write_format (const struct variable *v) } /* Sets V's write format specification to WRITE, which must be a - valid format specification for outputting a variable of V's - width. */ + valid format specification for a variable of V's width + (ordinarily an output format, but input formats are not + rejected). */ void var_set_write_format (struct variable *v, const struct fmt_spec *write) { @@ -629,14 +641,27 @@ var_set_write_format (struct variable *v, const struct fmt_spec *write) } /* Sets V's print and write format specifications to FORMAT, - which must be a valid format specification for outputting a - variable of V's width. */ + which must be a valid format specification for a variable of + V's width (ordinarily an output format, but input formats are + not rejected). */ void var_set_both_formats (struct variable *v, const struct fmt_spec *format) { var_set_print_format (v, format); var_set_write_format (v, format); } + +/* Returns the default print and write format for a variable of + the given TYPE, as set by var_create. The return value can be + used to reset a variable's print and write formats to the + default. */ +struct fmt_spec +var_default_formats (int width) +{ + return (width == 0 + ? fmt_for_output (FMT_F, 8, 2) + : fmt_for_output (FMT_A, width, 0)); +} /* Return a string representing this variable, in the form most appropriate from a human factors perspective, that is, its @@ -672,8 +697,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. */ @@ -714,6 +739,16 @@ var_set_measure (struct variable *v, enum measure measure) v->measure = measure; dict_var_changed (v); } + +/* Returns the default measurement level for a variable of the + given TYPE, as set by var_create. The return value can be + used to reset a variable's measurement level to the + default. */ +enum measure +var_default_measure (enum val_type type) +{ + return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL; +} /* Returns V's display width, which applies only to GUIs. */ int @@ -722,16 +757,28 @@ var_get_display_width (const struct variable *v) return v->display_width; } - - - /* 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); } + +/* Returns the default display width for a variable of the given + WIDTH, as set by var_create. The return value can be used to + reset a variable's display width to the default. */ +int +var_default_display_width (int width) +{ + return width == 0 ? 8 : MIN (width, 32); +} /* Returns true if A is a valid alignment, false otherwise. */ @@ -756,12 +803,21 @@ var_set_alignment (struct variable *v, enum alignment alignment) v->alignment = alignment; dict_var_changed (v); } + +/* Returns the default display alignment for a variable of the + given TYPE, as set by var_create. The return value can be + used to reset a variable's display alignment to the default. */ +enum alignment +var_default_alignment (enum val_type type) +{ + return type == VAL_NUMERIC ? ALIGN_RIGHT : ALIGN_LEFT; +} /* Whether variables' values should be preserved from case to case. */ /* Returns true if variable V's value should be left from case to - case, instead of being reset to 0, system-missing, or blanks. */ + case, instead of being reset to system-missing or blanks. */ bool var_get_leave (const struct variable *v) { @@ -782,7 +838,7 @@ var_set_leave (struct variable *v, bool leave) bool var_must_leave (const struct variable *v) { - return dict_class_from_id (v->name) == DC_SCRATCH; + return var_get_dict_class (v) == DC_SCRATCH; } /* Returns the number of short names stored in VAR. @@ -835,7 +891,6 @@ var_set_short_name (struct variable *var, size_t idx, const char *short_name) { size_t old_cnt = var->short_name_cnt; size_t i; - var->short_name_cnt = MAX (idx * 2, 1); var->short_names = xnrealloc (var->short_names, var->short_name_cnt, sizeof *var->short_names); @@ -854,9 +909,10 @@ void var_clear_short_names (struct variable *v) { size_t i; - + for (i = 0; i < v->short_name_cnt; i++) free (v->short_names[i]); + free (v->short_names); v->short_names = NULL; v->short_name_cnt = 0; } @@ -953,7 +1009,8 @@ var_get_obs_vals (const struct variable *v) return v->obs_vals; } -/* Sets V's observed categorical values to CAT_VALS. */ +/* Sets V's observed categorical values to CAT_VALS. + V becomes the owner of CAT_VALS. */ void var_set_obs_vals (const struct variable *v_, struct cat_vals *cat_vals) { @@ -970,37 +1027,29 @@ var_has_obs_vals (const struct variable *v) return v->obs_vals != NULL; } -/* Returns the dictionary class corresponding to a variable named - NAME. */ -enum dict_class -dict_class_from_id (const char *name) +/* 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) { - switch (name[0]) - { - default: - return DC_ORDINARY; - case '$': - return DC_SYSTEM; - case '#': - return DC_SCRATCH; - } + return (struct attrset *) &v->attributes; } -/* Returns the name of dictionary class DICT_CLASS. */ -const char * -dict_class_to_name (enum dict_class dict_class) +/* Replaces variable V's attributes set by a copy of ATTRS. */ +void +var_set_attributes (struct variable *v, const struct attrset *attrs) { - switch (dict_class) - { - case DC_ORDINARY: - return _("ordinary"); - case DC_SYSTEM: - return _("system"); - case DC_SCRATCH: - return _("scratch"); - default: - NOT_REACHED (); - } + attrset_destroy (&v->attributes); + attrset_clone (&v->attributes, attrs); +} + +/* Returns true if V has any custom attributes, false if it has none. */ +bool +var_has_attributes (const struct variable *v) +{ + return attrset_count (&v->attributes) > 0; } /* Returns V's vardict structure. */