#include <config.h>
#include "variable.h"
-#include <libpspp/assertion.h>
-#include <libpspp/message.h>
+
#include <stdlib.h>
+
+#include "cat-routines.h"
+#include "category.h"
+#include "data-out.h"
+#include "dictionary.h"
+#include "format.h"
+#include "identifier.h"
+#include "missing-values.h"
+#include "value.h"
+#include "value-labels.h"
+#include "vardict.h"
+
#include <libpspp/alloc.h>
+#include <libpspp/assertion.h>
#include <libpspp/compiler.h>
-#include "dictionary.h"
#include <libpspp/hash.h>
-#include "identifier.h"
+#include <libpspp/message.h>
#include <libpspp/misc.h>
#include <libpspp/str.h>
-#include "value-labels.h"
#include "minmax.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
+/* A variable. */
+struct variable
+ {
+ /* Dictionary information. */
+ char name[LONG_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. */
+ struct fmt_spec write; /* Default format for WRITE. */
+ struct val_labs *val_labs; /* Value labels. */
+ char *label; /* Variable label. */
+
+ /* GUI information. */
+ enum measure measure; /* Nominal, ordinal, or continuous. */
+ int display_width; /* Width of data editor column. */
+ enum alignment alignment; /* Alignment of data in GUI. */
+
+ /* Case information. */
+ bool leave; /* Leave value from case to case? */
+
+ /* Data for use by containing dictionary. */
+ struct vardict_info vardict;
+
+ /* Short name, used only for system and portable file input
+ and output. Upper case only. There is no index for short
+ names. Short names are not necessarily unique. Any
+ variable may have no short name, indicated by an empty
+ string. */
+ char short_name[SHORT_NAME_LEN + 1];
+
+ /* Each command may use these fields as needed. */
+ 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;
+ };
+
/* Returns true if VAR_TYPE is a valid variable type. */
bool
var_type_is_valid (enum var_type var_type)
{
- return var_type == NUMERIC || var_type == ALPHA;
-}
-
-/* Returns an adjective describing the given variable TYPE,
- suitable for use in phrases like "numeric variable". */
-const char *
-var_type_adj (enum var_type type)
-{
- return type == NUMERIC ? _("numeric") : _("string");
+ return var_type == VAR_NUMERIC || var_type == VAR_STRING;
}
-/* Returns a noun describing a value of the given variable TYPE,
- suitable for use in phrases like "a number". */
-const char *
-var_type_noun (enum var_type type)
-{
- return type == NUMERIC ? _("number") : _("string");
-}
-\f
-/* Returns true if M is a valid variable measurement level,
- false otherwise. */
-bool
-measure_is_valid (enum measure m)
-{
- return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
-}
-
-/* Returns true if A is a valid alignment,
- false otherwise. */
-bool
-alignment_is_valid (enum alignment a)
+/* Returns the variable type for the given width. */
+enum var_type
+var_type_from_width (int width)
{
- return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
+ return width != 0 ? VAR_STRING : VAR_NUMERIC;
}
\f
-/* 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. */
-void *
-var_attach_aux (struct variable *v,
- void *aux, void (*aux_dtor) (struct variable *))
-{
- 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 returns 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)
-{
- assert (v != NULL);
- if (v->aux != NULL)
+/* 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
+ dict_create_var instead. */
+struct variable *
+var_create (const char *name, int width)
+{
+ struct variable *v;
+
+ assert (width >= 0 && width <= MAX_STRING);
+
+ v = xmalloc (sizeof *v);
+ v->vardict.dict_index = v->vardict.case_index = -1;
+ var_set_name (v, name);
+ v->width = width;
+ mv_init (&v->miss, width);
+ v->leave = var_must_leave (v);
+ if (var_is_numeric (v))
{
- if (v->aux_dtor != NULL)
- v->aux_dtor (v);
- v->aux = NULL;
+ v->print = fmt_for_output (FMT_F, 8, 2);
+ v->alignment = ALIGN_RIGHT;
+ v->display_width = 8;
+ v->measure = MEASURE_SCALE;
}
-}
-
-/* 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);
-}
-
-/* Duplicate a value.
- The caller is responsible for freeing the returned value
-*/
-union value *
-value_dup (const union value *val, int width)
-{
- size_t bytes = MAX(width, sizeof *val);
+ 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;
+ v->val_labs = NULL;
+ v->label = NULL;
+ var_clear_short_name (v);
+ v->aux = NULL;
+ v->aux_dtor = NULL;
+ v->obs_vals = NULL;
- union value *v = xmalloc (bytes);
- memcpy (v, val, bytes);
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.
-/* Compares A and B, which both have the given WIDTH, and returns
- a strcmp()-type result. */
-int
-compare_values (const union value *a, const union value *b, int width)
-{
- if (width == 0)
- return a->f < b->f ? -1 : a->f > b->f;
- else
- return memcmp (a->s, b->s, MIN(MAX_SHORT_STRING, width));
-}
+ - The new variable is not added to OLD_VAR's dictionary by
+ default. Use dict_clone_var, instead, to do that.
-/* Create a hash of v */
-unsigned
-hash_value(const union value *v, int width)
+ - Auxiliary data and obs_vals are not copied. */
+struct variable *
+var_clone (const struct variable *old_var)
{
- unsigned id_hash;
+ struct variable *new_var = var_create (var_get_name (old_var),
+ var_get_width (old_var));
- if ( 0 == width )
- id_hash = hsh_hash_double (v->f);
- else
- id_hash = hsh_hash_bytes (v->s, MIN(MAX_SHORT_STRING, width));
+ 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));
+ 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));
- return id_hash;
+ return new_var;
+}
+
+/* Destroys variable V.
+ V must not belong to a dictionary. If it does, use
+ dict_delete_var instead. */
+void
+var_destroy (struct variable *v)
+{
+ if (v != NULL)
+ {
+ assert (!var_has_vardict (v));
+ cat_stored_values_destroy (v->obs_vals);
+ var_clear_aux (v);
+ val_labs_destroy (v->val_labs);
+ var_clear_label (v);
+ free (v);
+ }
}
\f
+/* Variable names. */
+
/* Return variable V's name. */
const char *
var_get_name (const struct variable *v)
return v->name;
}
-/* Sets V's name to NAME. */
+/* Sets V's name to NAME.
+ 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)
{
- assert (name[0] != '\0');
- assert (lex_id_to_token (ss_cstr (name)) == T_ID);
+ assert (v->vardict.dict_index == -1);
+ assert (var_is_plausible_name (name, false));
str_copy_trunc (v->name, sizeof v->name, name);
}
return true;
}
-/*
- Returns true if NAME is an plausible name for a variable,
+/* Returns true if NAME is an plausible name for a variable,
false otherwise. If ISSUE_ERROR is true, issues an
explanatory error message on failure.
This function makes no use of LC_CTYPE.
/* A hsh_compare_func that orders variables A and B by their
names. */
int
-compare_var_names (const void *a_, const void *b_, const void *aux UNUSED)
+compare_vars_by_name (const void *a_, const void *b_, const void *aux UNUSED)
{
const struct variable *a = a_;
const struct variable *b = b_;
- return strcasecmp (var_get_name (a), var_get_name (b));
+ return strcasecmp (a->name, b->name);
}
/* A hsh_hash_func that hashes variable V based on its name. */
unsigned
-hash_var_name (const void *v_, const void *aux UNUSED)
+hash_var_by_name (const void *v_, const void *aux UNUSED)
{
const struct variable *v = v_;
- return hsh_hash_case_string (var_get_name (v));
+ return hsh_hash_case_string (v->name);
}
/* A hsh_compare_func that orders pointers to variables A and B
by their names. */
int
-compare_var_ptr_names (const void *a_, const void *b_, const void *aux UNUSED)
+compare_var_ptrs_by_name (const void *a_, const void *b_,
+ const void *aux UNUSED)
{
struct variable *const *a = a_;
struct variable *const *b = b_;
/* A hsh_hash_func that hashes pointer to variable V based on its
name. */
unsigned
-hash_var_ptr_name (const void *v_, const void *aux UNUSED)
+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));
}
\f
-/* Returns the type of a variable with the given WIDTH. */
-static enum var_type
-width_to_type (int width)
-{
- return width == 0 ? NUMERIC : ALPHA;
-}
-
/* Returns the type of variable V. */
enum var_type
var_get_type (const struct variable *v)
{
- return width_to_type (v->width);
+ return var_type_from_width (v->width);
}
/* Returns the width of variable V. */
void
var_set_width (struct variable *v, int new_width)
{
- enum var_type new_type = width_to_type (new_width);
+ enum var_type new_type = var_type_from_width (new_width);
if (mv_is_resizable (&v->miss, new_width))
mv_resize (&v->miss, new_width);
if (var_get_type (v) != new_type)
{
- v->print = (new_type == NUMERIC
+ v->print = (new_type == VAR_NUMERIC
? fmt_for_output (FMT_F, 8, 2)
: fmt_for_output (FMT_A, new_width, 0));
v->write = v->print;
}
- else if (new_type == ALPHA)
+ else if (new_type == VAR_STRING)
{
v->print.w = v->print.type == FMT_AHEX ? new_width * 2 : new_width;
v->write.w = v->write.type == FMT_AHEX ? new_width * 2 : new_width;
bool
var_is_numeric (const struct variable *v)
{
- return var_get_type (v) == NUMERIC;
+ return var_get_type (v) == VAR_NUMERIC;
}
/* Returns true if variable V is a string variable, false
bool
var_is_alpha (const struct variable *v)
{
- return var_get_type (v) == ALPHA;
+ return var_get_type (v) == VAR_STRING;
}
/* Returns true if variable V is a short string variable, false
return v->width > MAX_SHORT_STRING;
}
-/* Returns true if variable V is a very long string variable,
- false otherwise. */
-bool
-var_is_very_long_string (const struct variable *v)
+/* 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 v->width > MAX_LONG_STRING;
+ return v->width == 0 ? 1 : DIV_RND_UP (v->width, MAX_SHORT_STRING);
}
-
+\f
/* Returns variable V's missing values. */
const struct missing_values *
var_get_missing_values (const struct variable *v)
return &v->miss;
}
-/* Sets variable V's missing values to MISS, which must be of the
- correct width. */
+/* 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)
{
if (miss != NULL)
{
- assert (v->width == mv_get_width (miss));
+ assert (mv_is_resizable (miss, v->width));
mv_copy (&v->miss, miss);
+ mv_resize (&v->miss, v->width);
}
else
mv_init (&v->miss, v->width);
return mv_is_value_system_missing (&v->miss, value);
}
\f
+/* Returns variable V's value labels,
+ possibly a null pointer if it has none. */
+const struct val_labs *
+var_get_value_labels (const struct variable *v)
+{
+ return v->val_labs;
+}
+
+/* Returns true if variable V has at least one value label. */
+bool
+var_has_value_labels (const struct variable *v)
+{
+ return val_labs_count (v->val_labs) > 0;
+}
+
+/* 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)
+{
+ val_labs_destroy (v->val_labs);
+ v->val_labs = NULL;
+
+ if (vls != NULL)
+ {
+ assert (val_labs_can_set_width (vls, v->width));
+ v->val_labs = val_labs_copy (vls);
+ val_labs_set_width (v->val_labs, v->width);
+ }
+}
+
+/* Makes sure that V has a set of value labels,
+ by assigning one to it if necessary. */
+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. */
+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);
+}
+
+/* Adds or replaces a value label with the given VALUE and LABEL
+ to V.
+ V must not be 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);
+}
+
+/* Removes V's value labels, if any. */
+void
+var_clear_value_labels (struct variable *v)
+{
+ var_set_value_labels (v, NULL);
+}
+
+/* Returns the label associated with VALUE for variable V,
+ or a null pointer if none. */
+const char *
+var_lookup_value_label (const struct variable *v, const union value *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)
+{
+ 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;
+ }
+ return name;
+}
+\f
/* Print and write formats. */
/* Returns V's print format specification. */
var_set_write_format (v, format);
}
\f
+/* 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;
+}
+
/* Returns V's variable label, or a null pointer if it has none. */
const char *
var_get_label (const struct variable *v)
return v->label != NULL;
}
\f
+/* Returns true if M is a valid variable measurement level,
+ false otherwise. */
+bool
+measure_is_valid (enum measure m)
+{
+ return m == MEASURE_NOMINAL || m == MEASURE_ORDINAL || m == MEASURE_SCALE;
+}
+
/* Returns V's measurement level. */
enum measure
var_get_measure (const struct variable *v)
assert (measure_is_valid (measure));
v->measure = measure;
}
-
+\f
/* Returns V's display width, which applies only to GUIs. */
int
var_get_display_width (const struct variable *v)
{
v->display_width = display_width;
}
+\f
+/* Returns true if A is a valid alignment,
+ false otherwise. */
+bool
+alignment_is_valid (enum alignment a)
+{
+ return a == ALIGN_LEFT || a == ALIGN_RIGHT || a == ALIGN_CENTRE;
+}
/* Returns V's display alignment, which applies only to GUIs. */
enum alignment
v->alignment = alignment;
}
\f
-/* 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 v->width == 0 ? 1 : DIV_RND_UP (v->width, MAX_SHORT_STRING);
-}
+/* Whether variables' values should be preserved from case to
+ case. */
-/* Return whether variable V's 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. */
bool
var_get_leave (const struct variable *v)
{
return v->leave;
}
+
+/* Sets V's leave setting to LEAVE. */
+void
+var_set_leave (struct variable *v, bool leave)
+{
+ assert (leave || !var_must_leave (v));
+ v->leave = leave;
+}
+
+/* Returns true if V must be left from case to case,
+ false if it can be set either way. */
+bool
+var_must_leave (const struct variable *v)
+{
+ return dict_class_from_id (v->name) == DC_SCRATCH;
+}
\f
/* Returns V's short name, if it has one, or a null pointer
otherwise.
v->short_name[0] = '\0';
}
+\f
+/* Relationship with dictionary. */
-/* Sets V's short name to BASE, followed by a suffix of the form
- _A, _B, _C, ..., _AA, _AB, etc. according to the value of
- SUFFIX_NUMBER. Truncates BASE as necessary to fit. */
-void
-var_set_short_name_suffix (struct variable *v, const char *base,
- int suffix_number)
+/* Returns V's index within its dictionary, the value
+ for which "dict_get_var (dict, index)" will return V.
+ V must be in a dictionary. */
+size_t
+var_get_dict_index (const struct variable *v)
{
- char suffix[SHORT_NAME_LEN + 1];
- char short_name[SHORT_NAME_LEN + 1];
- char *start, *end;
- int len, ofs;
+ assert (v->vardict.dict_index != -1);
+ return v->vardict.dict_index;
+}
- assert (v != NULL);
- assert (suffix_number >= 0);
+/* Returns V's index within the case represented by its
+ dictionary, that is, the value for which "case_data_idx (case,
+ index)" will return the data for V in that case.
+ V must be in a dictionary. */
+size_t
+var_get_case_index (const struct variable *v)
+{
+ assert (v->vardict.case_index != -1);
+ return v->vardict.case_index;
+}
+\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 (struct variable *v,
+ void *aux, void (*aux_dtor) (struct variable *))
+{
+ assert (v->aux == NULL);
+ assert (aux != NULL);
+ v->aux = aux;
+ v->aux_dtor = aux_dtor;
+ return aux;
+}
- /* Set base name. */
- var_set_short_name (v, base);
+/* 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;
+}
- /* Compose suffix. */
- start = end = suffix + sizeof suffix - 1;
- *end = '\0';
- do
+/* Clears auxiliary data, if any, from V, and calls any
+ associated destructor. */
+void
+var_clear_aux (struct variable *v)
+{
+ assert (v != NULL);
+ if (v->aux != NULL)
{
- *--start = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[suffix_number % 26];
- if (start <= suffix + 1)
- msg (SE, _("Variable suffix too large."));
- suffix_number /= 26;
+ if (v->aux_dtor != NULL)
+ v->aux_dtor (v);
+ v->aux = NULL;
}
- while (suffix_number > 0);
- *--start = '_';
-
- /* Append suffix to V's short name. */
- str_copy_trunc (short_name, sizeof short_name, base);
- len = end - start;
- if (len + strlen (short_name) > SHORT_NAME_LEN)
- ofs = SHORT_NAME_LEN - len;
- else
- ofs = strlen (short_name);
- strcpy (short_name + ofs, start);
+}
- /* Set name. */
- var_set_short_name (v, short_name);
+/* 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
+/* Observed categorical values. */
+/* Returns V's observed categorical values,
+ which V must have. */
+struct cat_vals *
+var_get_obs_vals (const struct variable *v)
+{
+ assert (v->obs_vals != NULL);
+ return v->obs_vals;
+}
+/* Sets V's observed categorical values to CAT_VALS. */
+void
+var_set_obs_vals (struct variable *v, struct cat_vals *cat_vals)
+{
+ cat_stored_values_destroy (v->obs_vals);
+ v->obs_vals = cat_vals;
+}
+
+/* Returns true if V has observed categorical values,
+ false otherwise. */
+bool
+var_has_obs_vals (const struct variable *v)
+{
+ return v->obs_vals != NULL;
+}
+\f
/* Returns the dictionary class corresponding to a variable named
NAME. */
enum dict_class
dict_class_from_id (const char *name)
{
- assert (name != NULL);
-
switch (name[0])
{
default:
NOT_REACHED ();
}
}
-
-/* Return the number of bytes used when writing case_data for a variable
- of WIDTH */
-int
-width_to_bytes(int width)
+\f
+/* Returns V's vardict structure. */
+const struct vardict_info *
+var_get_vardict (const struct variable *v)
{
- assert (width >= 0);
+ assert (var_has_vardict (v));
+ return &v->vardict;
+}
- if ( width == 0 )
- return MAX_SHORT_STRING ;
- else if (width <= MAX_LONG_STRING)
- return ROUND_UP (width, MAX_SHORT_STRING);
- else
- {
- int chunks = width / EFFECTIVE_LONG_STRING_LENGTH ;
- int remainder = width % EFFECTIVE_LONG_STRING_LENGTH ;
- int bytes = remainder + (chunks * (MAX_LONG_STRING + 1) );
- return ROUND_UP (bytes, MAX_SHORT_STRING);
- }
+/* Sets V's vardict data to VARDICT. */
+void
+var_set_vardict (struct variable *v, const struct vardict_info *vardict)
+{
+ assert (vardict->dict_index >= 0);
+ assert (vardict->case_index >= 0);
+ v->vardict = *vardict;
}
+/* Returns true if V has vardict data. */
+bool
+var_has_vardict (const struct variable *v)
+{
+ return v->vardict.dict_index != -1;
+}
+/* Clears V's vardict data. */
+void
+var_clear_vardict (struct variable *v)
+{
+ v->vardict.dict_index = v->vardict.case_index = -1;
+}
projects / pspp-builds.git / blobdiff