/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2012, 2013,
+ 2014, 2016, 2020 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
#include "gettext.h"
#define _(msgid) gettext (msgid)
+#define N_(msgid) (msgid)
+
+/* This should follow the definition in Gtk */
+typedef struct
+{
+ int value;
+ const char *name;
+ const char *label;
+} GEnumValue;
+
+const GEnumValue align[] =
+ {
+ {ALIGN_LEFT, "left", N_("Left")},
+ {ALIGN_RIGHT, "right", N_("Right")},
+ {ALIGN_CENTRE, "center", N_("Center")},
+ {0,0,0}
+ };
+
+const GEnumValue measure[] =
+ {
+ {MEASURE_UNKNOWN, "unknown", N_("Unknown")},
+ {MEASURE_NOMINAL, "nominal", N_("Nominal")},
+ {MEASURE_ORDINAL, "ordinal", N_("Ordinal")},
+ {MEASURE_SCALE, "scale", N_("Scale")},
+ {0,0,0}
+ };
+
+const GEnumValue role[] =
+ {
+ {ROLE_INPUT, "input", N_("Input")},
+ {ROLE_TARGET, "output", N_("Output")},
+ {ROLE_BOTH, "both", N_("Both")},
+ {ROLE_NONE, "none", N_("None")},
+ {ROLE_PARTITION, "partition", N_("Partition")},
+ {ROLE_SPLIT, "split", N_("Split")},
+ {0,0,0}
+ };
/* A variable. */
struct variable
{
+ int ref_cnt;
/* Dictionary information. */
char *name; /* Variable name. Mixed case. */
int width; /* 0 for numeric, otherwise string width. */
/* GUI information. */
enum measure measure; /* Nominal, ordinal, or continuous. */
+ enum var_role role; /* Intended use. */
int display_width; /* Width of data editor column. */
enum alignment alignment; /* Alignment of data in GUI. */
/* Used only for system and portable file input and output.
See short-names.h. */
char **short_names;
- size_t short_name_cnt;
+ size_t n_short_names;
/* 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_print_format_quiet (struct variable *v, const struct fmt_spec *print);
+static void var_set_write_format_quiet (struct variable *v, const struct fmt_spec *write);
+static void var_set_label_quiet (struct variable *v, const char *label);
static void var_set_name_quiet (struct variable *v, const char *name);
/* Creates and returns a new variable with the given NAME and
struct variable *
var_create (const char *name, int width)
{
- struct variable *v;
enum val_type type;
assert (width >= 0 && width <= MAX_STRING);
- v = xzalloc (sizeof *v);
+ struct variable *v = XZALLOC (struct variable);
var_set_name_quiet (v, name);
v->width = width;
mv_init (&v->miss, width);
v->leave = var_must_leave (v);
type = val_type_from_width (width);
v->alignment = var_default_alignment (type);
- v->measure = var_default_measure (type);
+ v->measure = var_default_measure_for_type (type);
+ v->role = ROLE_INPUT;
v->display_width = var_default_display_width (width);
v->print = v->write = var_default_formats (width);
attrset_init (&v->attributes);
ds_init_empty (&v->name_and_label);
+ v->ref_cnt = 1;
+
return v;
}
/* Destroys variable V.
V must not belong to a dictionary. If it does, use
dict_delete_var instead. */
+static void
+var_destroy__ (struct variable *v)
+{
+ assert (!var_has_vardict (v));
+ mv_destroy (&v->miss);
+ var_clear_short_names (v);
+ val_labs_destroy (v->val_labs);
+ var_set_label_quiet (v, NULL);
+ attrset_destroy (var_get_attributes (v));
+ free (v->name);
+ ds_destroy (&v->name_and_label);
+ free (v);
+}
+
+struct variable *
+var_ref (struct variable *v)
+{
+ v->ref_cnt++;
+ return v;
+}
+
void
-var_destroy (struct variable *v)
+var_unref (struct variable *v)
{
- if (v != NULL)
- {
- assert (!var_has_vardict (v));
- mv_destroy (&v->miss);
- var_clear_short_names (v);
- val_labs_destroy (v->val_labs);
- var_set_label_quiet (v, NULL, false);
- attrset_destroy (var_get_attributes (v));
- free (v->name);
- ds_destroy (&v->name_and_label);
- free (v);
- }
+ if (--v->ref_cnt == 0)
+ var_destroy__ (v);
}
+
+
\f
/* Variable names. */
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);
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);
+ dict_var_changed (v, VAR_TRAIT_NAME, ov);
}
/* Returns VAR's dictionary class. */
return v->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)
+var_set_width_and_formats (struct variable *v, int new_width,
+ const struct fmt_spec *print, const struct fmt_spec *write)
{
- const int old_width = v->width;
+ struct variable *ov;
+ unsigned int traits = 0;
- if (old_width == new_width)
- return;
+ ov = var_clone (v);
if (mv_is_resizable (&v->miss, new_width))
mv_resize (&v->miss, new_width);
mv_destroy (&v->miss);
mv_init (&v->miss, new_width);
}
+ if (new_width != var_get_width (v))
+ traits |= VAR_TRAIT_MISSING_VALUES;
if (v->val_labs != NULL)
{
val_labs_destroy (v->val_labs);
v->val_labs = NULL;
}
+ traits |= VAR_TRAIT_VALUE_LABELS;
+ }
+
+ if (fmt_resize (&v->print, new_width))
+ traits |= VAR_TRAIT_PRINT_FORMAT;
+
+ if (fmt_resize (&v->write, new_width))
+ traits |= VAR_TRAIT_WRITE_FORMAT;
+
+ if (v->width != new_width)
+ {
+ v->width = new_width;
+ traits |= VAR_TRAIT_WIDTH;
+ }
+
+ if (print)
+ {
+ var_set_print_format_quiet (v, print);
+ traits |= VAR_TRAIT_PRINT_FORMAT;
+ }
+
+ if (write)
+ {
+ var_set_write_format_quiet (v, write);
+ traits |= VAR_TRAIT_WRITE_FORMAT;
}
- fmt_resize (&v->print, new_width);
- fmt_resize (&v->write, new_width);
+ if (traits != 0)
+ dict_var_changed (v, traits, ov);
+}
+
+/* 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;
- v->width = new_width;
- dict_var_resized (v, old_width);
- dict_var_changed (v);
+ var_set_width_and_formats (v, new_width, NULL, NULL);
}
+
+
+
/* Returns true if variable V is numeric, false otherwise. */
bool
var_is_numeric (const struct variable *v)
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);
+ dict_var_changed (v, VAR_TRAIT_MISSING_VALUES, ov);
}
/* Sets variable V to have no user-missing values. */
return !mv_is_empty (&v->miss);
}
-/* Returns true if VALUE is in the given CLASS of missing values
- in V, false otherwise. */
-bool
-var_is_value_missing (const struct variable *v, const union value *value,
- enum mv_class class)
+/* Returns MV_SYSTEM if VALUE is system-missing, MV_USER if VALUE is
+ user-missing for V, and otherwise 0. */
+enum mv_class
+var_is_value_missing (const struct variable *v, const union value *value)
{
- return mv_is_value_missing (&v->miss, value, class);
+ return mv_is_value_missing (&v->miss, value);
}
-/* Returns true if D is in the given CLASS of missing values in
- V, false otherwise.
- V must be a numeric variable. */
-bool
-var_is_num_missing (const struct variable *v, double d, enum mv_class class)
+/* Returns MV_SYSTEM if VALUE is system-missing, MV_USER if VALUE is
+ user-missing for V, and otherwise 0. V must be a numeric variable. */
+enum mv_class
+var_is_num_missing (const struct variable *v, double d)
{
- return mv_is_num_missing (&v->miss, d, class);
+ return mv_is_num_missing (&v->miss, d);
}
-/* Returns true if S[] is a missing value for V, false otherwise.
- 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 uint8_t s[],
- enum mv_class class)
+/* Returns MV_USER if VALUE is user-missing for V and otherwise 0. V must be
+ a string variable. */
+enum mv_class
+var_is_str_missing (const struct variable *v, const uint8_t s[])
{
- return mv_is_str_missing (&v->miss, s, class);
+ return mv_is_str_missing (&v->miss, s);
}
\f
/* Returns variable V's value labels,
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);
+ dict_var_changed (v, VAR_TRAIT_LABEL, ov);
}
append_value (const struct variable *v, const union value *value,
struct string *str)
{
- char *s = data_out (value, var_get_encoding (v), &v->print);
- ds_put_cstr (str, s);
+ char *s = data_out (value, var_get_encoding (v), &v->print,
+ settings_get_fmt_settings ());
+ struct substring ss = ss_cstr (s);
+ ss_rtrim (&ss, ss_cstr (" "));
+ ds_put_substring (str, ss);
free (s);
}
-/* 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)
+var_append_value_name__ (const struct variable *v, const union value *value,
+ enum settings_value_show show, struct string *str)
{
- enum settings_value_style style = settings_get_value_style ();
- const char *name = var_lookup_value_label (v, value);
+ const char *label = var_lookup_value_label (v, value);
- switch (style)
+ switch (show)
{
- case SETTINGS_VAL_STYLE_VALUES:
+ case SETTINGS_VALUE_SHOW_VALUE:
append_value (v, value, str);
break;
-
- case SETTINGS_VAL_STYLE_LABELS:
- if (name == NULL)
- append_value (v, value, str);
+
+ default:
+ case SETTINGS_VALUE_SHOW_LABEL:
+ if (label)
+ ds_put_cstr (str, label);
else
- ds_put_cstr (str, name);
+ append_value (v, value, str);
break;
- case SETTINGS_VAL_STYLE_BOTH:
- default:
+ case SETTINGS_VALUE_SHOW_BOTH:
append_value (v, value, str);
- if (name != NULL)
- {
- ds_put_cstr (str, " (");
- ds_put_cstr (str, name);
- ds_put_cstr (str, ")");
- }
+ if (label != NULL)
+ ds_put_format (str, " %s", label);
break;
- };
+ }
+}
+
+/* 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)
+{
+ var_append_value_name__ (v, value, settings_get_show_values (), str);
}
\f
/* Print and write formats. */
void
var_set_print_format (struct variable *v, const struct fmt_spec *print)
{
+ struct variable *ov = var_clone (v);
var_set_print_format_quiet (v, print);
- dict_var_changed (v);
+ dict_var_changed (v, VAR_TRAIT_PRINT_FORMAT, ov);
}
/* Returns V's write format specification. */
void
var_set_write_format (struct variable *v, const struct fmt_spec *write)
{
+ struct variable *ov = var_clone (v);
var_set_write_format_quiet (v, write);
- dict_var_changed (v);
+ dict_var_changed (v, VAR_TRAIT_WRITE_FORMAT, ov);
}
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_PRINT_FORMAT | VAR_TRAIT_WRITE_FORMAT, ov);
}
/* Returns the default print and write format for a variable of
const char *
var_to_string (const struct variable *v)
{
- enum settings_var_style style = settings_get_var_style ();
-
- switch (style)
- {
- case SETTINGS_VAR_STYLE_NAMES:
+ switch (settings_get_show_variables ())
+ {
+ case SETTINGS_VALUE_SHOW_VALUE:
return v->name;
- break;
- case SETTINGS_VAR_STYLE_LABELS:
+
+ case SETTINGS_VALUE_SHOW_LABEL:
+ default:
return v->label != NULL ? v->label : v->name;
- break;
- case SETTINGS_VAR_STYLE_BOTH:
+
+ case SETTINGS_VALUE_SHOW_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. */
/* 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. */
-static bool
-var_set_label_quiet (struct variable *v, const char *label, bool issue_warning)
+ is removed. */
+static void
+var_set_label_quiet (struct variable *v, const char *label)
{
- bool truncated = false;
-
free (v->label);
v->label = NULL;
if (label != NULL && label[strspn (label, CC_SPACES)])
- {
- const char *dict_encoding = var_get_encoding (v);
- struct substring s = ss_cstr (label);
- size_t trunc_len;
-
- if (dict_encoding != NULL)
- {
- enum { MAX_LABEL_LEN = 255 };
-
- trunc_len = utf8_encoding_trunc_len (label, dict_encoding,
- MAX_LABEL_LEN);
- if (ss_length (s) > trunc_len)
- {
- if (issue_warning)
- msg (SW, _("Truncating variable label for variable `%s' to %d "
- "bytes."), var_get_name (v), MAX_LABEL_LEN);
- ss_truncate (&s, trunc_len);
- truncated = true;
- }
- }
-
- v->label = ss_xstrdup (s);
- }
+ v->label = xstrdup (label);
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)
+ is removed. */
+void
+var_set_label (struct variable *v, const char *label)
{
- bool truncated = var_set_label_quiet (v, label, issue_warning);
-
- dict_var_changed (v);
-
- return truncated;
+ struct variable *ov = var_clone (v);
+ var_set_label_quiet (v, label);
+ dict_var_changed (v, VAR_TRAIT_LABEL, ov);
}
void
var_clear_label (struct variable *v)
{
- var_set_label (v, NULL, false);
+ var_set_label (v, NULL);
}
/* Returns true if V has a variable V,
bool
measure_is_valid (enum measure m)
{
- return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
+ return (m == MEASURE_UNKNOWN || m == MEASURE_NOMINAL
+ || m == MEASURE_ORDINAL || m == MEASURE_SCALE);
}
-/* Returns a string version of measurement level M, for display to a user. */
+/* Returns a string version of measurement level M, for display to a user.
+ The caller may translate the string by passing it to gettext(). */
const char *
measure_to_string (enum measure m)
+{
+ assert (m == measure[m].value);
+ return measure[m].label;
+}
+
+/* Returns a string version of measurement level M, for use in PSPP command
+ syntax. */
+const char *
+measure_to_syntax (enum measure m)
{
switch (m)
{
case MEASURE_NOMINAL:
- return _("Nominal");
+ return "NOMINAL";
case MEASURE_ORDINAL:
- return _("Ordinal");
+ return "ORDINAL";
case MEASURE_SCALE:
- return _("Scale");
+ return "SCALE";
default:
return "Invalid";
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);
+ dict_var_changed (v, VAR_TRAIT_MEASURE, ov);
}
used to reset a variable's measurement level to the
default. */
enum measure
-var_default_measure (enum val_type type)
+var_default_measure_for_type (enum val_type type)
+{
+ return type == VAL_NUMERIC ? MEASURE_UNKNOWN : MEASURE_NOMINAL;
+}
+
+/* Returns the default measurement level for a variable with the given
+ FORMAT, or MEASURE_UNKNOWN if there is no good default. */
+enum measure
+var_default_measure_for_format (enum fmt_type format)
+{
+ if (format == FMT_DOLLAR)
+ return MEASURE_SCALE;
+
+ switch (fmt_get_category (format))
+ {
+ case FMT_CAT_BASIC:
+ case FMT_CAT_LEGACY:
+ case FMT_CAT_BINARY:
+ case FMT_CAT_HEXADECIMAL:
+ return MEASURE_UNKNOWN;
+
+ case FMT_CAT_CUSTOM:
+ case FMT_CAT_DATE:
+ case FMT_CAT_TIME:
+ return MEASURE_SCALE;
+
+ case FMT_CAT_DATE_COMPONENT:
+ case FMT_CAT_STRING:
+ return MEASURE_NOMINAL;
+ }
+
+ NOT_REACHED ();
+}
+\f
+/* Returns true if M is a valid variable role,
+ false otherwise. */
+bool
+var_role_is_valid (enum var_role role)
+{
+ switch (role)
+ {
+ case ROLE_NONE:
+ case ROLE_INPUT:
+ case ROLE_TARGET:
+ case ROLE_BOTH:
+ case ROLE_PARTITION:
+ case ROLE_SPLIT:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+/* Returns a string version of ROLE, for display to a user.
+ The caller may translate the string by passing it to gettext(). */
+const char *
+var_role_to_string (enum var_role r)
+{
+ assert (r == role[r].value);
+ return role[r].label;
+}
+
+/* Returns a string version of ROLE, for use in PSPP comamnd syntax. */
+const char *
+var_role_to_syntax (enum var_role role)
+{
+ switch (role)
+ {
+ case ROLE_INPUT:
+ return "INPUT";
+
+ case ROLE_TARGET:
+ return "TARGET";
+
+ case ROLE_BOTH:
+ return "BOTH";
+
+ case ROLE_NONE:
+ return "NONE";
+
+ case ROLE_PARTITION:
+ return "PARTITION";
+
+ case ROLE_SPLIT:
+ return "SPLIT";
+
+ default:
+ return "<invalid>";
+ }
+}
+
+/* Returns V's role. */
+enum var_role
+var_get_role (const struct variable *v)
+{
+ return v->role;
+}
+
+/* Sets V's role to ROLE. */
+static void
+var_set_role_quiet (struct variable *v, enum var_role role)
{
- return type == VAL_NUMERIC ? MEASURE_SCALE : MEASURE_NOMINAL;
+ assert (var_role_is_valid (role));
+ v->role = role;
+}
+
+
+/* Sets V's role to ROLE. */
+void
+var_set_role (struct variable *v, enum var_role role)
+{
+ struct variable *ov = var_clone (v);
+ var_set_role_quiet (v, role);
+ dict_var_changed (v, VAR_TRAIT_ROLE, ov);
}
\f
/* Returns V's display width, which applies only to GUIs. */
if (v->display_width != new_width)
{
v->display_width = new_width;
- dict_var_display_width_changed (v);
}
}
void
var_set_display_width (struct variable *v, int new_width)
{
- var_set_display_width_quiet (v, new_width);
- dict_var_changed (v);
+ if (v->display_width != 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. */
return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
}
-/* Returns a string version of alignment A, for display to a user. */
+/* Returns a string version of alignment A, for display to a user.
+ The caller may translate the string by passing it to gettext(). */
const char *
alignment_to_string (enum alignment a)
+{
+ assert (a == align[a].value);
+ return align[a].label;
+}
+
+/* Returns a string version of alignment A, for use in PSPP command syntax. */
+const char *
+alignment_to_syntax (enum alignment a)
{
switch (a)
{
case ALIGN_LEFT:
- return _("Left");
+ return "LEFT";
case ALIGN_RIGHT:
- return _("Right");
+ return "RIGHT";
case ALIGN_CENTRE:
- return _("Center");
+ return "CENTER";
default:
return "Invalid";
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);
+ dict_var_changed (v, VAR_TRAIT_ALIGNMENT, ov);
}
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);
+ dict_var_changed (v, VAR_TRAIT_LEAVE, ov);
}
all if it hasn't been saved to or read from a system or
portable file. */
size_t
-var_get_short_name_cnt (const struct variable *var)
+var_get_n_short_names (const struct variable *var)
{
- return var->short_name_cnt;
+ return var->n_short_names;
}
/* Returns VAR's short name with the given IDX, if it has one
const char *
var_get_short_name (const struct variable *var, size_t idx)
{
- return idx < var->short_name_cnt ? var->short_names[idx] : NULL;
+ return idx < var->n_short_names ? var->short_names[idx] : NULL;
}
/* Sets VAR's short name with the given IDX to the UTF-8 string SHORT_NAME.
void
var_set_short_name (struct variable *var, size_t idx, const char *short_name)
{
- assert (short_name == NULL || id_is_plausible (short_name, false));
+ struct variable *ov = var_clone (var);
/* Clear old short name numbered IDX, if any. */
- if (idx < var->short_name_cnt)
+ if (idx < var->n_short_names)
{
free (var->short_names[idx]);
- var->short_names[idx] = NULL;
+ var->short_names[idx] = NULL;
}
/* Install new short name for IDX. */
- if (short_name != NULL)
+ if (short_name != NULL)
{
- if (idx >= var->short_name_cnt)
+ if (idx >= var->n_short_names)
{
- size_t old_cnt = var->short_name_cnt;
+ size_t n_old = var->n_short_names;
size_t i;
- var->short_name_cnt = MAX (idx * 2, 1);
- var->short_names = xnrealloc (var->short_names, var->short_name_cnt,
+ var->n_short_names = MAX (idx * 2, 1);
+ var->short_names = xnrealloc (var->short_names, var->n_short_names,
sizeof *var->short_names);
- for (i = old_cnt; i < var->short_name_cnt; i++)
+ for (i = n_old; i < var->n_short_names; i++)
var->short_names[i] = NULL;
}
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. */
{
size_t i;
- for (i = 0; i < v->short_name_cnt; i++)
+ for (i = 0; i < v->n_short_names; i++)
free (v->short_names[i]);
free (v->short_names);
v->short_names = NULL;
- v->short_name_cnt = 0;
+ v->n_short_names = 0;
}
\f
/* Relationship with dictionary. */
V, or calling var_set_attributes() on V, will also destroy its
attribute set. */
struct attrset *
-var_get_attributes (const struct variable *v)
+var_get_attributes (const struct variable *v)
{
return CONST_CAST (struct attrset *, &v->attributes);
}
/* Replaces variable V's attributes set by a copy of ATTRS. */
static void
-var_set_attributes_quiet (struct variable *v, const struct attrset *attrs)
+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)
+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);
+ dict_var_changed (v, VAR_TRAIT_ATTRIBUTES, ov);
}
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_label_quiet (new_var, var_get_label (old_var));
var_set_measure_quiet (new_var, var_get_measure (old_var));
+ var_set_role_quiet (new_var, var_get_role (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));
{
v->vardict = NULL;
}
+
+\f
+/*
+ Returns zero, if W is a missing value for WV or if it is less than zero.
+ Typically used to force a numerical value into a valid weight.
+
+ As a side effect, this function will emit a warning if the value
+ WARN_ON_INVALID points to a bool which is TRUE. That bool will be then
+ set to FALSE.
+ */
+double
+var_force_valid_weight (const struct variable *wv, double w, bool *warn_on_invalid)
+{
+ if (w < 0.0 || (wv && var_is_num_missing (wv, w)))
+ w = 0.0;
+
+ if (w == 0.0 && warn_on_invalid != NULL && *warn_on_invalid)
+ {
+ *warn_on_invalid = false;
+ msg (SW, _("At least one case in the data file had a weight value "
+ "that was user-missing, system-missing, zero, or "
+ "negative. These case(s) were ignored."));
+ }
+
+ return w;
+}
projects / pspp / blobdiff