/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012 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
struct fmt_spec write; /* Default format for WRITE. */
struct val_labs *val_labs; /* Value labels. */
char *label; /* Variable label. */
+ struct string name_and_label; /* The name and label in the same string */
/* GUI information. */
enum measure measure; /* Nominal, ordinal, or continuous. */
char **short_names;
size_t short_name_cnt;
- /* Each command may use these fields as needed. */
- void *aux;
- void (*aux_dtor) (struct variable *);
-
/* Custom attributes. */
struct attrset attributes;
};
\f
+
+static bool var_set_label_quiet (struct variable *v, const char *label, bool issue_warning);
+static void var_set_name_quiet (struct variable *v, const char *name);
+
/* Creates and returns a new variable with the given NAME and
WIDTH and other fields initialized to default values. The
variable is not added to a dictionary; for that, use
assert (width >= 0 && width <= MAX_STRING);
- v = xmalloc (sizeof *v);
- v->vardict = NULL;
- v->name = NULL;
- var_set_name (v, name);
+ v = xzalloc (sizeof *v);
+ var_set_name_quiet (v, name);
v->width = width;
mv_init (&v->miss, width);
v->leave = var_must_leave (v);
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;
- v->short_name_cnt = 0;
- v->aux = NULL;
- v->aux_dtor = NULL;
attrset_init (&v->attributes);
+ ds_init_empty (&v->name_and_label);
return v;
}
-/* Creates and returns a clone of OLD_VAR. Most properties of
- the new variable are copied from OLD_VAR, except:
-
- - The variable's short name is not copied, because there is
- no reason to give a new variable with potentially a new
- name the same short name.
-
- - The new variable is not added to OLD_VAR's dictionary by
- default. Use dict_clone_var, instead, to do that.
-*/
-struct variable *
-var_clone (const struct variable *old_var)
-{
- struct variable *new_var = var_create (var_get_name (old_var),
- var_get_width (old_var));
-
- var_set_missing_values (new_var, var_get_missing_values (old_var));
- var_set_print_format (new_var, var_get_print_format (old_var));
- var_set_write_format (new_var, var_get_write_format (old_var));
- var_set_value_labels (new_var, var_get_value_labels (old_var));
- var_set_label (new_var, var_get_label (old_var), false);
- var_set_measure (new_var, var_get_measure (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;
-}
-
/* Destroys variable V.
V must not belong to a dictionary. If it does, use
dict_delete_var instead. */
assert (!var_has_vardict (v));
mv_destroy (&v->miss);
var_clear_short_names (v);
- var_clear_aux (v);
val_labs_destroy (v->val_labs);
- var_clear_label (v);
+ var_set_label_quiet (v, NULL, false);
attrset_destroy (var_get_attributes (v));
free (v->name);
+ ds_destroy (&v->name_and_label);
free (v);
}
}
return v->name;
}
+
+
/* Sets V's name to NAME, a UTF-8 encoded string.
Do not use this function for a variable in a dictionary. Use
dict_rename_var instead. */
-void
-var_set_name (struct variable *v, const char *name)
+static void
+var_set_name_quiet (struct variable *v, const char *name)
{
assert (!var_has_vardict (v));
assert (id_is_plausible (name, false));
free (v->name);
v->name = xstrdup (name);
- dict_var_changed (v);
+ ds_destroy (&v->name_and_label);
+ ds_init_empty (&v->name_and_label);
+}
+
+/* Sets V's name to NAME, a UTF-8 encoded string.
+ Do not use this function for a variable in a dictionary. Use
+ dict_rename_var instead. */
+void
+var_set_name (struct variable *v, const char *name)
+{
+ struct variable *ov = var_clone (v);
+ var_set_name_quiet (v, name);
+ dict_var_changed (v, VAR_TRAIT_NAME, ov);
}
/* Returns VAR's dictionary class. */
const struct variable *a = a_;
const struct variable *b = b_;
- return strcasecmp (a->name, b->name);
+ return utf8_strcasecmp (a->name, b->name);
}
/* A hsh_hash_func that hashes variable V based on its name. */
{
const struct variable *v = v_;
- return hash_case_string (v->name, 0);
+ return utf8_hash_case_string (v->name, 0);
}
/* A hsh_compare_func that orders pointers to variables A and B
struct variable *const *a = a_;
struct variable *const *b = b_;
- return strcasecmp (var_get_name (*a), var_get_name (*b));
+ return utf8_strcasecmp (var_get_name (*a), var_get_name (*b));
}
/* A hsh_compare_func that orders pointers to variables A and B
{
struct variable *const *v = v_;
- return hash_case_string (var_get_name (*v), 0);
+ return utf8_hash_case_string (var_get_name (*v), 0);
}
\f
/* Returns the type of variable V. */
void
var_set_width (struct variable *v, int new_width)
{
+ struct variable *ov;
const int old_width = v->width;
if (old_width == new_width)
return;
+ ov = var_clone (v);
+
if (mv_is_resizable (&v->miss, new_width))
mv_resize (&v->miss, new_width);
else
v->width = new_width;
dict_var_resized (v, old_width);
- dict_var_changed (v);
+ dict_var_changed (v, VAR_TRAIT_WIDTH, ov);
}
/* Returns true if variable V is numeric, false otherwise. */
width or at least resizable to V's width.
If MISS is null, then V's missing values, if any, are
cleared. */
-void
-var_set_missing_values (struct variable *v, const struct missing_values *miss)
+static void
+var_set_missing_values_quiet (struct variable *v, const struct missing_values *miss)
{
if (miss != NULL)
{
}
else
mv_clear (&v->miss);
+}
- dict_var_changed (v);
+/* Sets variable V's missing values to MISS, which must be of V's
+ width or at least resizable to V's width.
+ If MISS is null, then V's missing values, if any, are
+ cleared. */
+void
+var_set_missing_values (struct variable *v, const struct missing_values *miss)
+{
+ struct variable *ov = var_clone (v);
+ var_set_missing_values_quiet (v, miss);
+ dict_var_changed (v, VAR_TRAIT_MISSING_VALUES, ov);
}
/* Sets variable V to have no user-missing values. */
which must have a width equal to V's width or one that can be
changed to V's width.
If VLS is null, then V's value labels, if any, are removed. */
-void
-var_set_value_labels (struct variable *v, const struct val_labs *vls)
+static void
+var_set_value_labels_quiet (struct variable *v, const struct val_labs *vls)
{
val_labs_destroy (v->val_labs);
v->val_labs = NULL;
assert (val_labs_can_set_width (vls, v->width));
v->val_labs = val_labs_clone (vls);
val_labs_set_width (v->val_labs, v->width);
- dict_var_changed (v);
}
}
+
+/* Sets variable V's value labels to a copy of VLS,
+ which must have a width equal to V's width or one that can be
+ changed to V's width.
+ If VLS is null, then V's value labels, if any, are removed. */
+void
+var_set_value_labels (struct variable *v, const struct val_labs *vls)
+{
+ struct variable *ov = var_clone (v);
+ var_set_value_labels_quiet (v, vls);
+ dict_var_changed (v, VAR_TRAIT_LABEL, ov);
+}
+
+
/* Makes sure that V has a set of value labels,
by assigning one to it if necessary. */
static void
return &v->print;
}
+/* Sets V's print format specification to PRINT, which must be a
+ valid format specification for a variable of V's width
+ (ordinarily an output format, but input formats are not
+ rejected). */
+static void
+var_set_print_format_quiet (struct variable *v, const struct fmt_spec *print)
+{
+ if (!fmt_equal (&v->print, print))
+ {
+ assert (fmt_check_width_compat (print, v->width));
+ v->print = *print;
+ }
+}
+
/* Sets V's print format specification to PRINT, which must be a
valid format specification for a variable of V's width
(ordinarily an output format, but input formats are not
void
var_set_print_format (struct variable *v, const struct fmt_spec *print)
{
- assert (fmt_check_width_compat (print, v->width));
- v->print = *print;
- dict_var_changed (v);
+ struct variable *ov = var_clone (v);
+ var_set_print_format_quiet (v, print);
+ dict_var_changed (v, VAR_TRAIT_FORMAT, ov);
}
/* Returns V's write format specification. */
return &v->write;
}
+/* Sets V's write format specification to WRITE, which must be a
+ valid format specification for a variable of V's width
+ (ordinarily an output format, but input formats are not
+ rejected). */
+static void
+var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write)
+{
+ if (!fmt_equal (&v->write, write))
+ {
+ assert (fmt_check_width_compat (write, v->width));
+ v->write = *write;
+ }
+}
+
/* Sets V's write format specification to WRITE, which must be a
valid format specification for a variable of V's width
(ordinarily an output format, but input formats are not
void
var_set_write_format (struct variable *v, const struct fmt_spec *write)
{
- assert (fmt_check_width_compat (write, v->width));
- v->write = *write;
- dict_var_changed (v);
+ struct variable *ov = var_clone (v);
+ var_set_write_format_quiet (v, write);
+ dict_var_changed (v, VAR_TRAIT_FORMAT, ov);
}
+
/* Sets V's print and write format specifications to FORMAT,
which must be a valid format specification for a variable of
V's width (ordinarily an output format, but input formats are
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);
+ struct variable *ov = var_clone (v);
+ var_set_print_format_quiet (v, format);
+ var_set_write_format_quiet (v, format);
+ dict_var_changed (v, VAR_TRAIT_FORMAT, ov);
}
/* Returns the default print and write format for a variable of
? fmt_for_output (FMT_F, 8, 2)
: fmt_for_output (FMT_A, width, 0));
}
+
+
\f
+
+/* Update the combined name and label string if necessary */
+static void
+update_vl_string (const struct variable *v)
+{
+ /* Cast away const! */
+ struct string *str = (struct string *) &v->name_and_label;
+
+ if (ds_is_empty (str))
+ {
+ if (v->label)
+ ds_put_format (str, _("%s (%s)"), v->label, v->name);
+ else
+ ds_put_cstr (str, v->name);
+ }
+}
+
+
/* Return a string representing this variable, in the form most
appropriate from a human factors perspective, that is, its
variable label if it has one, otherwise its name. */
const char *
var_to_string (const struct variable *v)
{
- return v->label != NULL ? v->label : v->name;
+ enum settings_var_style style = settings_get_var_style ();
+
+ switch (style)
+ {
+ case SETTINGS_VAR_STYLE_NAMES:
+ return v->name;
+ break;
+ case SETTINGS_VAR_STYLE_LABELS:
+ return v->label != NULL ? v->label : v->name;
+ break;
+ case SETTINGS_VAR_STYLE_BOTH:
+ update_vl_string (v);
+ return ds_cstr (&v->name_and_label);
+ break;
+ default:
+ NOT_REACHED ();
+ break;
+ };
}
/* Returns V's variable label, or a null pointer if it has none. */
var_get_encoding()). If LABEL fits within this limit, this function returns
true. Otherwise, the variable label is set to a truncated value, this
function returns false and, if ISSUE_WARNING is true, issues a warning. */
-bool
-var_set_label (struct variable *v, const char *label, bool issue_warning)
+static bool
+var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
{
bool truncated = false;
v->label = ss_xstrdup (s);
}
- dict_var_changed (v);
+ ds_destroy (&v->name_and_label);
+ ds_init_empty (&v->name_and_label);
return truncated;
}
+
+
+/* Sets V's variable label to UTF-8 encoded string LABEL, stripping off leading
+ and trailing white space. If LABEL is a null pointer or if LABEL is an
+ empty string (after stripping white space), then V's variable label (if any)
+ is removed.
+
+ Variable labels are limited to 255 bytes in V's encoding (as returned by
+ var_get_encoding()). If LABEL fits within this limit, this function returns
+ true. Otherwise, the variable label is set to a truncated value, this
+ function returns false and, if ISSUE_WARNING is true, issues a warning. */
+bool
+var_set_label (struct variable *v, const char *label, bool issue_warning)
+{
+ struct variable *ov = var_clone (v);
+ bool truncated = var_set_label_quiet (v, label, issue_warning);
+
+ dict_var_changed (v, VAR_TRAIT_LABEL, ov);
+
+ return truncated;
+}
+
+
/* Removes any variable label from V. */
void
var_clear_label (struct variable *v)
}
/* Sets V's measurement level to MEASURE. */
-void
-var_set_measure (struct variable *v, enum measure measure)
+static void
+var_set_measure_quiet (struct variable *v, enum measure measure)
{
assert (measure_is_valid (measure));
v->measure = measure;
- dict_var_changed (v);
}
+
+/* Sets V's measurement level to MEASURE. */
+void
+var_set_measure (struct variable *v, enum measure measure)
+{
+ struct variable *ov = var_clone (v);
+ var_set_measure_quiet (v, measure);
+ dict_var_changed (v, VAR_TRAIT_MEASURE, ov);
+}
+
+
/* 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
}
/* Sets V's display width to DISPLAY_WIDTH. */
-void
-var_set_display_width (struct variable *v, int new_width)
+static void
+var_set_display_width_quiet (struct variable *v, int new_width)
{
if (v->display_width != new_width)
{
v->display_width = new_width;
dict_var_display_width_changed (v);
- dict_var_changed (v);
}
}
+void
+var_set_display_width (struct variable *v, int new_width)
+{
+ struct variable *ov = var_clone (v);
+ var_set_display_width_quiet (v, new_width);
+ dict_var_changed (v, VAR_TRAIT_DISPLAY_WIDTH, ov);
+}
+
+
/* 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. */
}
/* Sets V's display alignment to ALIGNMENT. */
-void
-var_set_alignment (struct variable *v, enum alignment alignment)
+static void
+var_set_alignment_quiet (struct variable *v, enum alignment alignment)
{
assert (alignment_is_valid (alignment));
v->alignment = alignment;
- dict_var_changed (v);
}
+/* Sets V's display alignment to ALIGNMENT. */
+void
+var_set_alignment (struct variable *v, enum alignment alignment)
+{
+ struct variable *ov = var_clone (v);
+ var_set_alignment_quiet (v, alignment);
+ dict_var_changed (v, VAR_TRAIT_ALIGNMENT, ov);
+}
+
+
/* 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. */
}
/* Sets V's leave setting to LEAVE. */
-void
-var_set_leave (struct variable *v, bool leave)
+static void
+var_set_leave_quiet (struct variable *v, bool leave)
{
assert (leave || !var_must_leave (v));
v->leave = leave;
- dict_var_changed (v);
}
+
+/* Sets V's leave setting to LEAVE. */
+void
+var_set_leave (struct variable *v, bool leave)
+{
+ struct variable *ov = var_clone (v);
+ var_set_leave_quiet (v, leave);
+ dict_var_changed (v, VAR_TRAIT_LEAVE, ov);
+}
+
+
/* Returns true if V must be left from case to case,
false if it can be set either way. */
bool
void
var_set_short_name (struct variable *var, size_t idx, const char *short_name)
{
+ struct variable *ov = var_clone (var);
+
assert (short_name == NULL || id_is_plausible (short_name, false));
/* Clear old short name numbered IDX, if any. */
for (i = old_cnt; i < var->short_name_cnt; i++)
var->short_names[i] = NULL;
}
- var->short_names[idx] = xstrdup (short_name);
- str_uppercase (var->short_names[idx]);
+ var->short_names[idx] = utf8_to_upper (short_name);
}
- dict_var_changed (var);
+ dict_var_changed (var, VAR_TRAIT_NAME, ov);
}
/* Clears V's short names. */
return vardict_get_case_index (v->vardict);
}
\f
-/* Returns V's auxiliary data, or a null pointer if none has been
- attached. */
-void *
-var_get_aux (const struct variable *v)
-{
- return v->aux;
-}
-
-/* Assign auxiliary data AUX to variable V, which must not
- already have auxiliary data. Before V's auxiliary data is
- cleared, AUX_DTOR(V) will be called. (var_dtor_free, below,
- may be appropriate for use as AUX_DTOR.) */
-void *
-var_attach_aux (const struct variable *v_,
- void *aux, void (*aux_dtor) (struct variable *))
-{
- struct variable *v = CONST_CAST (struct variable *, v_);
- assert (v->aux == NULL);
- assert (aux != NULL);
- v->aux = aux;
- v->aux_dtor = aux_dtor;
- return aux;
-}
-
-/* Remove auxiliary data, if any, from V, and return it, without
- calling any associated destructor. */
-void *
-var_detach_aux (struct variable *v)
-{
- void *aux = v->aux;
- assert (aux != NULL);
- v->aux = NULL;
- return aux;
-}
-
-/* Clears auxiliary data, if any, from V, and calls any
- associated destructor. */
-void
-var_clear_aux (struct variable *v)
-{
- if (v->aux != NULL)
- {
- if (v->aux_dtor != NULL)
- v->aux_dtor (v);
- v->aux = NULL;
- }
-}
-
-/* This function is appropriate for use an auxiliary data
- destructor (passed as AUX_DTOR to var_attach_aux()) for the
- case where the auxiliary data should be passed to free(). */
-void
-var_dtor_free (struct variable *v)
-{
- free (v->aux);
-}
-\f
/* 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
}
/* Replaces variable V's attributes set by a copy of ATTRS. */
-void
-var_set_attributes (struct variable *v, const struct attrset *attrs)
+static void
+var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
{
attrset_destroy (&v->attributes);
attrset_clone (&v->attributes, attrs);
}
+/* Replaces variable V's attributes set by a copy of ATTRS. */
+void
+var_set_attributes (struct variable *v, const struct attrset *attrs)
+{
+ struct variable *ov = var_clone (v);
+ var_set_attributes_quiet (v, attrs);
+ dict_var_changed (v, VAR_TRAIT_ATTRIBUTES, ov);
+}
+
+
/* 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;
}
\f
+
+/* Creates and returns a clone of OLD_VAR. Most properties of
+ the new variable are copied from OLD_VAR, except:
+
+ - The variable's short name is not copied, because there is
+ no reason to give a new variable with potentially a new
+ name the same short name.
+
+ - The new variable is not added to OLD_VAR's dictionary by
+ default. Use dict_clone_var, instead, to do that.
+*/
+struct variable *
+var_clone (const struct variable *old_var)
+{
+ struct variable *new_var = var_create (var_get_name (old_var),
+ var_get_width (old_var));
+
+ var_set_missing_values_quiet (new_var, var_get_missing_values (old_var));
+ var_set_print_format_quiet (new_var, var_get_print_format (old_var));
+ var_set_write_format_quiet (new_var, var_get_write_format (old_var));
+ var_set_value_labels_quiet (new_var, var_get_value_labels (old_var));
+ var_set_label_quiet (new_var, var_get_label (old_var), false);
+ var_set_measure_quiet (new_var, var_get_measure (old_var));
+ var_set_display_width_quiet (new_var, var_get_display_width (old_var));
+ var_set_alignment_quiet (new_var, var_get_alignment (old_var));
+ var_set_leave_quiet (new_var, var_get_leave (old_var));
+ var_set_attributes_quiet (new_var, var_get_attributes (old_var));
+
+ return new_var;
+}
+
+
+
/* 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. */
projects / pspp / blobdiff