/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2007, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010 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 <config.h>
-#include "dictionary.h"
+#include "data/dictionary.h"
+#include <stdint.h>
#include <stdlib.h>
#include <ctype.h>
-#include <data/attributes.h>
-#include <data/case.h>
-#include <data/identifier.h>
-#include <data/settings.h>
-#include <data/value-labels.h>
-#include <data/vardict.h>
-#include <data/variable.h>
-#include <data/vector.h>
-#include <libpspp/array.h>
-#include <libpspp/assertion.h>
-#include <libpspp/compiler.h>
-#include <libpspp/hash.h>
-#include <libpspp/message.h>
-#include <libpspp/misc.h>
-#include <libpspp/pool.h>
-#include <libpspp/str.h>
-
-#include "intprops.h"
-#include "minmax.h"
-#include "xalloc.h"
+#include "data/attributes.h"
+#include "data/case.h"
+#include "data/identifier.h"
+#include "data/mrset.h"
+#include "data/settings.h"
+#include "data/value-labels.h"
+#include "data/vardict.h"
+#include "data/variable.h"
+#include "data/vector.h"
+#include "libpspp/array.h"
+#include "libpspp/assertion.h"
+#include "libpspp/compiler.h"
+#include "libpspp/hash-functions.h"
+#include "libpspp/hmap.h"
+#include "libpspp/message.h"
+#include "libpspp/misc.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+
+#include "gl/intprops.h"
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
/* A dictionary. */
struct dictionary
{
- struct variable **var; /* Variables. */
+ struct vardict_info *var; /* Variables. */
size_t var_cnt, var_cap; /* Number of variables, capacity. */
struct caseproto *proto; /* Prototype for dictionary cases
(updated lazily). */
- struct hsh_table *name_tab; /* Variable index by name. */
+ struct hmap name_map; /* Variable index by name. */
int next_value_idx; /* Index of next `union value' to allocate. */
const struct variable **split; /* SPLIT FILE vars. */
size_t split_cnt; /* SPLIT FILE count. */
struct vector **vector; /* Vectors of variables. */
size_t vector_cnt; /* Number of vectors. */
struct attrset attributes; /* Custom attributes. */
+ struct mrset **mrsets; /* Multiple response sets. */
+ size_t n_mrsets; /* Number of multiple response sets. */
char *encoding; /* Character encoding of string data */
void *changed_data;
};
+static void dict_unset_split_var (struct dictionary *, struct variable *);
+static void dict_unset_mrset_var (struct dictionary *, struct variable *);
void
dict_set_encoding (struct dictionary *d, const char *enc)
{
if (enc)
- d->encoding = xstrdup (enc);
+ {
+ free (d->encoding);
+ d->encoding = xstrdup (enc);
+ }
}
const char *
int i;
for (i = 0 ; i < d->var_cnt ; ++i )
{
- const struct variable *v =
- d->var[i];
+ const struct variable *v = d->var[i].var;
printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n",
var_get_name (v),
var_get_dict_index (v),
{
struct dictionary *d = xzalloc (sizeof *d);
- d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name,
- NULL, NULL);
+ hmap_init (&d->name_map);
attrset_init (&d->attributes);
return d;
}
struct dictionary *d;
size_t i;
- assert (s != NULL);
-
d = dict_create ();
for (i = 0; i < s->var_cnt; i++)
{
- const struct vardict_info *svdi;
- struct vardict_info dvdi;
- struct variable *sv = s->var[i];
- struct variable *dv = dict_clone_var_assert (d, sv, var_get_name (sv));
+ struct variable *sv = s->var[i].var;
+ struct variable *dv = dict_clone_var_assert (d, sv);
size_t i;
for (i = 0; i < var_get_short_name_cnt (sv); i++)
var_set_short_name (dv, i, var_get_short_name (sv, i));
- svdi = var_get_vardict (sv);
- dvdi = *svdi;
- dvdi.dict = d;
- var_set_vardict (dv, &dvdi);
+ var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index;
}
d->next_value_idx = s->next_value_idx;
dict_set_attributes (d, dict_get_attributes (s));
+ for (i = 0; i < s->n_mrsets; i++)
+ {
+ const struct mrset *old = s->mrsets[i];
+ struct mrset *new;
+ size_t j;
+
+ /* Clone old mrset, then replace vars from D by vars from S. */
+ new = mrset_clone (old);
+ for (j = 0; j < new->n_vars; j++)
+ new->vars[j] = dict_lookup_var_assert (d, var_get_name (new->vars[j]));
+
+ dict_add_mrset (d, new);
+ }
+
return d;
}
{
/* FIXME? Should we really clear case_limit, label, documents?
Others are necessarily cleared by deleting all the variables.*/
- assert (d != NULL);
-
while (d->var_cnt > 0 )
{
- dict_delete_var (d, d->var[d->var_cnt - 1]);
+ dict_delete_var (d, d->var[d->var_cnt - 1].var);
}
free (d->var);
d->var = NULL;
d->var_cnt = d->var_cap = 0;
invalidate_proto (d);
- hsh_clear (d->name_tab);
+ hmap_clear (&d->name_map);
d->next_value_idx = 0;
dict_set_split_vars (d, NULL, 0);
dict_set_weight (d, NULL);
{
int i;
- assert (d != NULL);
-
for (i = 0; i < d->var_cnt; i++)
- var_clear_aux (d->var[i]);
+ var_clear_aux (d->var[i].var);
}
/* Clears a dictionary and destroys it. */
d->callbacks = NULL ;
dict_clear (d);
- hsh_destroy (d->name_tab);
+ hmap_destroy (&d->name_map);
attrset_destroy (&d->attributes);
+ free (d->mrsets);
free (d);
}
}
size_t
dict_get_var_cnt (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->var_cnt;
}
struct variable *
dict_get_var (const struct dictionary *d, size_t idx)
{
- assert (d != NULL);
assert (idx < d->var_cnt);
- return d->var[idx];
+ return d->var[idx].var;
}
/* Sets *VARS to an array of pointers to variables in D and *CNT
size_t count;
size_t i;
- assert (d != NULL);
- assert (vars != NULL);
- assert (cnt != NULL);
assert (exclude == (exclude & DC_ALL));
count = 0;
for (i = 0; i < d->var_cnt; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i]);
+ enum dict_class class = var_get_dict_class (d->var[i].var);
if (!(class & exclude))
count++;
}
*cnt = 0;
for (i = 0; i < d->var_cnt; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i]);
+ enum dict_class class = var_get_dict_class (d->var[i].var);
if (!(class & exclude))
- (*vars)[(*cnt)++] = d->var[i];
+ (*vars)[(*cnt)++] = d->var[i].var;
}
assert (*cnt == count);
}
static struct variable *
add_var (struct dictionary *d, struct variable *v)
{
- /* Add dictionary info to variable. */
- struct vardict_info vdi;
- vdi.case_index = d->next_value_idx;
- vdi.dict_index = d->var_cnt;
- vdi.dict = d;
- var_set_vardict (v, &vdi);
+ struct vardict_info *vardict;
/* Update dictionary. */
if (d->var_cnt >= d->var_cap)
{
- d->var_cap = 8 + 2 * d->var_cap;
- d->var = xnrealloc (d->var, d->var_cap, sizeof *d->var);
+ size_t i;
+
+ d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var);
+ hmap_clear (&d->name_map);
+ for (i = 0; i < d->var_cnt; i++)
+ {
+ var_set_vardict (d->var[i].var, &d->var[i]);
+ hmap_insert_fast (&d->name_map, &d->var[i].name_node,
+ d->var[i].name_node.hash);
+ }
}
- d->var[d->var_cnt++] = v;
- hsh_force_insert (d->name_tab, v);
+
+ vardict = &d->var[d->var_cnt++];
+ vardict->dict = d;
+ vardict->var = v;
+ hmap_insert (&d->name_map, &vardict->name_node,
+ hash_case_string (var_get_name (v), 0));
+ vardict->case_index = d->next_value_idx;
+ var_set_vardict (v, vardict);
if ( d->changed ) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->var_added )
return add_var (d, var_create (name, width));
}
-/* Creates and returns a new variable in D with name NAME, as a
- copy of existing variable OLD_VAR, which need not be in D or
- in any dictionary. Returns a null pointer if the given NAME
- would duplicate that of an existing variable in the
+/* Creates and returns a new variable in D, as a copy of existing variable
+ OLD_VAR, which need not be in D or in any dictionary. Returns a null
+ pointer if OLD_VAR's name would duplicate that of an existing variable in
+ the dictionary. */
+struct variable *
+dict_clone_var (struct dictionary *d, const struct variable *old_var)
+{
+ return dict_clone_var_as (d, old_var, var_get_name (old_var));
+}
+
+/* Creates and returns a new variable in D, as a copy of existing variable
+ OLD_VAR, which need not be in D or in any dictionary. Assert-fails if
+ OLD_VAR's name would duplicate that of an existing variable in the
dictionary. */
struct variable *
-dict_clone_var (struct dictionary *d, const struct variable *old_var,
- const char *name)
+dict_clone_var_assert (struct dictionary *d, const struct variable *old_var)
+{
+ return dict_clone_var_as_assert (d, old_var, var_get_name (old_var));
+}
+
+/* Creates and returns a new variable in D with name NAME, as a copy of
+ existing variable OLD_VAR, which need not be in D or in any dictionary.
+ Returns a null pointer if the given NAME would duplicate that of an existing
+ variable in the dictionary. */
+struct variable *
+dict_clone_var_as (struct dictionary *d, const struct variable *old_var,
+ const char *name)
{
return (dict_lookup_var (d, name) == NULL
- ? dict_clone_var_assert (d, old_var, name)
+ ? dict_clone_var_as_assert (d, old_var, name)
: NULL);
}
-/* Creates and returns a new variable in D with name NAME, as a
- copy of existing variable OLD_VAR, which need not be in D or
- in any dictionary. Assert-fails if the given NAME would
- duplicate that of an existing variable in the dictionary. */
+/* Creates and returns a new variable in D with name NAME, as a copy of
+ existing variable OLD_VAR, which need not be in D or in any dictionary.
+ Assert-fails if the given NAME would duplicate that of an existing variable
+ in the dictionary. */
struct variable *
-dict_clone_var_assert (struct dictionary *d, const struct variable *old_var,
- const char *name)
+dict_clone_var_as_assert (struct dictionary *d, const struct variable *old_var,
+ const char *name)
{
struct variable *new_var = var_clone (old_var);
assert (dict_lookup_var (d, name) == NULL);
struct variable *
dict_lookup_var (const struct dictionary *d, const char *name)
{
- struct variable *target ;
- struct variable *result ;
-
- if ( ! var_is_plausible_name (name, false))
- return NULL;
+ struct vardict_info *vardict;
- target = var_create (name, 0);
- result = hsh_find (d->name_tab, target);
- var_destroy (target);
-
- if ( result && var_has_vardict (result))
- {
- const struct vardict_info *vdi = var_get_vardict (result);
- assert (vdi->dict == d);
- }
+ HMAP_FOR_EACH_WITH_HASH (vardict, struct vardict_info, name_node,
+ hash_case_string (name, 0), &d->name_map)
+ {
+ struct variable *var = vardict->var;
+ if (!strcasecmp (var_get_name (var), name))
+ return var;
+ }
- return result;
+ return NULL;
}
/* Returns the variable named NAME in D. Assert-fails if no
bool
dict_contains_var (const struct dictionary *d, const struct variable *v)
{
- if (var_has_vardict (v))
- {
- const struct vardict_info *vdi = var_get_vardict (v);
- return (vdi->dict_index >= 0
- && vdi->dict_index < d->var_cnt
- && d->var[vdi->dict_index] == v);
- }
- else
- return false;
+ return (var_has_vardict (v)
+ && vardict_get_dictionary (var_get_vardict (v)) == d);
}
/* Compares two double pointers to variables, which should point
return *a < *b ? -1 : *a > *b;
}
-/* Sets the dict_index in V's vardict to DICT_INDEX. */
static void
-set_var_dict_index (struct variable *v, int dict_index)
+unindex_var (struct dictionary *d, struct vardict_info *vardict)
+{
+ hmap_delete (&d->name_map, &vardict->name_node);
+}
+
+/* This function assumes that vardict->name_node.hash is valid, that is, that
+ its name has not changed since it was hashed (rename_var() updates this
+ hash along with the name itself). */
+static void
+reindex_var (struct dictionary *d, struct vardict_info *vardict)
{
- struct vardict_info vdi = *var_get_vardict (v);
- struct dictionary *d = vdi.dict;
- vdi.dict_index = dict_index;
- var_set_vardict (v, &vdi);
+ struct variable *var = vardict->var;
+
+ var_set_vardict (var, vardict);
+ hmap_insert_fast (&d->name_map, &vardict->name_node,
+ vardict->name_node.hash);
if ( d->changed ) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->var_changed )
- d->callbacks->var_changed (d, dict_index, d->cb_data);
+ d->callbacks->var_changed (d, var_get_dict_index (var), d->cb_data);
}
/* Sets the case_index in V's vardict to CASE_INDEX. */
static void
set_var_case_index (struct variable *v, int case_index)
{
- struct vardict_info vdi = *var_get_vardict (v);
- vdi.case_index = case_index;
- var_set_vardict (v, &vdi);
+ var_get_vardict (v)->case_index = case_index;
+}
+
+/* Removes the dictionary variables with indexes from FROM to TO (exclusive)
+ from name_map. */
+static void
+unindex_vars (struct dictionary *d, size_t from, size_t to)
+{
+ size_t i;
+
+ for (i = from; i < to; i++)
+ unindex_var (d, &d->var[i]);
}
/* Re-sets the dict_index in the dictionary variables with
size_t i;
for (i = from; i < to; i++)
- set_var_dict_index (d->var[i], i);
+ reindex_var (d, &d->var[i]);
}
/* Deletes variable V from dictionary D and frees V.
var_clear_aux (v);
dict_unset_split_var (d, v);
+ dict_unset_mrset_var (d, v);
if (d->weight == v)
dict_set_weight (d, NULL);
dict_clear_vectors (d);
/* Remove V from var array. */
+ unindex_vars (d, dict_index, d->var_cnt);
remove_element (d->var, d->var_cnt, sizeof *d->var, dict_index);
d->var_cnt--;
/* Update dict_index for each affected variable. */
reindex_vars (d, dict_index, d->var_cnt);
- /* Update name hash. */
- hsh_force_delete (d->name_tab, v);
-
-
/* Free memory. */
var_clear_vardict (v);
var_destroy (v);
{
/* FIXME: this can be done in O(count) time, but this algorithm
is O(count**2). */
- assert (d != NULL);
assert (count == 0 || vars != NULL);
while (count-- > 0)
assert (idx + count <= d->var_cnt);
while (count-- > 0)
- dict_delete_var (d, d->var[idx]);
+ dict_delete_var (d, d->var[idx].var);
}
/* Deletes scratch variables from dictionary D. */
/* FIXME: this can be done in O(count) time, but this algorithm
is O(count**2). */
- assert (d != NULL);
-
for (i = 0; i < d->var_cnt; )
- if (var_get_dict_class (d->var[i]) == DC_SCRATCH)
- dict_delete_var (d, d->var[i]);
+ if (var_get_dict_class (d->var[i].var) == DC_SCRATCH)
+ dict_delete_var (d, d->var[i].var);
else
i++;
}
size_t old_index = var_get_dict_index (v);
assert (new_index < d->var_cnt);
+
+ unindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
move_element (d->var, d->var_cnt, sizeof *d->var, old_index, new_index);
reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1);
}
dict_reorder_vars (struct dictionary *d,
struct variable *const *order, size_t count)
{
- struct variable **new_var;
+ struct vardict_info *new_var;
size_t i;
- assert (d != NULL);
assert (count == 0 || order != NULL);
assert (count <= d->var_cnt);
- new_var = xnmalloc (d->var_cnt, sizeof *new_var);
- memcpy (new_var, order, count * sizeof *new_var);
+ new_var = xnmalloc (d->var_cap, sizeof *new_var);
+
+ /* Add variables in ORDER to new_var. */
for (i = 0; i < count; i++)
{
- size_t index = var_get_dict_index (order[i]);
- assert (d->var[index] == order[i]);
- d->var[index] = NULL;
- set_var_dict_index (order[i], i);
+ struct vardict_info *old_var;
+
+ assert (dict_contains_var (d, order[i]));
+
+ old_var = var_get_vardict (order[i]);
+ new_var[i] = *old_var;
+ old_var->dict = NULL;
}
+
+ /* Add remaining variables to new_var. */
for (i = 0; i < d->var_cnt; i++)
- if (d->var[i] != NULL)
- {
- assert (count < d->var_cnt);
- new_var[count] = d->var[i];
- set_var_dict_index (new_var[count], count);
- count++;
- }
+ if (d->var[i].dict != NULL)
+ new_var[count++] = d->var[i];
+ assert (count == d->var_cnt);
+
+ /* Replace old vardicts by new ones. */
free (d->var);
d->var = new_var;
+
+ hmap_clear (&d->name_map);
+ reindex_vars (d, 0, d->var_cnt);
}
-/* Changes the name of variable V in dictionary D to NEW_NAME. */
+/* Changes the name of variable V that is currently in a dictionary to
+ NEW_NAME. */
static void
-rename_var (struct dictionary *d, struct variable *v, const char *new_name)
+rename_var (struct variable *v, const char *new_name)
{
- struct vardict_info vdi;
-
- assert (dict_contains_var (d, v));
-
- vdi = *var_get_vardict (v);
+ struct vardict_info *vardict = var_get_vardict (v);
var_clear_vardict (v);
var_set_name (v, new_name);
- var_set_vardict (v, &vdi);
+ vardict->name_node.hash = hash_case_string (new_name, 0);
+ var_set_vardict (v, vardict);
}
/* Changes the name of V in D to name NEW_NAME. Assert-fails if
assert (!strcasecmp (var_get_name (v), new_name)
|| dict_lookup_var (d, new_name) == NULL);
- hsh_force_delete (d->name_tab, v);
- rename_var (d, v, new_name);
- hsh_force_insert (d->name_tab, v);
+ unindex_var (d, var_get_vardict (v));
+ rename_var (v, new_name);
+ reindex_var (d, var_get_vardict (v));
if (settings_get_algorithm () == ENHANCED)
var_clear_short_names (v);
and rename them. */
for (i = 0; i < count; i++)
{
- hsh_force_delete (d->name_tab, vars[i]);
- rename_var (d, vars[i], new_names[i]);
+ unindex_var (d, var_get_vardict (vars[i]));
+ rename_var (vars[i], new_names[i]);
}
/* Add the renamed variables back into the name hash,
checking for conflicts. */
for (i = 0; i < count; i++)
- if (hsh_insert (d->name_tab, vars[i]) != NULL)
- {
- /* There is a name conflict.
- Back out all the name changes that have already
- taken place, and indicate failure. */
- size_t fail_idx = i;
- if (err_name != NULL)
- *err_name = new_names[i];
-
- for (i = 0; i < fail_idx; i++)
- hsh_force_delete (d->name_tab, vars[i]);
-
- for (i = 0; i < count; i++)
- {
- rename_var (d, vars[i], old_names[i]);
- hsh_force_insert (d->name_tab, vars[i]);
- }
-
- pool_destroy (pool);
- return false;
- }
+ {
+ if (dict_lookup_var (d, var_get_name (vars[i])) != NULL)
+ {
+ /* There is a name conflict.
+ Back out all the name changes that have already
+ taken place, and indicate failure. */
+ size_t fail_idx = i;
+ if (err_name != NULL)
+ *err_name = new_names[i];
+
+ for (i = 0; i < fail_idx; i++)
+ unindex_var (d, var_get_vardict (vars[i]));
+
+ for (i = 0; i < count; i++)
+ {
+ rename_var (vars[i], old_names[i]);
+ reindex_var (d, var_get_vardict (vars[i]));
+ }
+
+ pool_destroy (pool);
+ return false;
+ }
+ reindex_var (d, var_get_vardict (vars[i]));
+ }
/* Clear short names. */
if (settings_get_algorithm () == ENHANCED)
struct variable *
dict_get_weight (const struct dictionary *d)
{
- assert (d != NULL);
assert (d->weight == NULL || dict_contains_var (d, d->weight));
return d->weight;
dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
bool *warn_on_invalid)
{
- assert (d != NULL);
assert (c != NULL);
if (d->weight == NULL)
void
dict_set_weight (struct dictionary *d, struct variable *v)
{
- assert (d != NULL);
assert (v == NULL || dict_contains_var (d, v));
assert (v == NULL || var_is_numeric (v));
struct variable *
dict_get_filter (const struct dictionary *d)
{
- assert (d != NULL);
assert (d->filter == NULL || dict_contains_var (d, d->filter));
return d->filter;
void
dict_set_filter (struct dictionary *d, struct variable *v)
{
- assert (d != NULL);
assert (v == NULL || dict_contains_var (d, v));
assert (v == NULL || var_is_numeric (v));
casenumber
dict_get_case_limit (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->case_limit;
}
void
dict_set_case_limit (struct dictionary *d, casenumber case_limit)
{
- assert (d != NULL);
-
d->case_limit = case_limit;
}
const struct caseproto *
dict_get_proto (const struct dictionary *d_)
{
- struct dictionary *d = (struct dictionary *) d_;
+ struct dictionary *d = CONST_CAST (struct dictionary *, d_);
if (d->proto == NULL)
{
size_t i;
d->proto = caseproto_reserve (d->proto, d->var_cnt);
for (i = 0; i < d->var_cnt; i++)
d->proto = caseproto_set_width (d->proto,
- var_get_case_index (d->var[i]),
- var_get_width (d->var[i]));
+ var_get_case_index (d->var[i].var),
+ var_get_width (d->var[i].var));
}
return d->proto;
}
int
dict_get_next_value_idx (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->next_value_idx;
}
size_t
dict_get_case_size (const struct dictionary *d)
{
- assert (d != NULL);
-
return sizeof (union value) * dict_get_next_value_idx (d);
}
d->next_value_idx = 0;
for (i = 0; i < d->var_cnt; i++)
{
- struct variable *v = d->var[i];
+ struct variable *v = d->var[i].var;
set_var_case_index (v, d->next_value_idx++);
}
invalidate_proto (d);
cnt = 0;
for (i = 0; i < d->var_cnt; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i]);
+ enum dict_class class = var_get_dict_class (d->var[i].var);
if (!(exclude_classes & (1u << class)))
cnt++;
}
proto = caseproto_create ();
for (i = 0; i < d->var_cnt; i++)
{
- struct variable *v = d->var[i];
+ struct variable *v = d->var[i].var;
if (!(exclude_classes & (1u << var_get_dict_class (v))))
proto = caseproto_add_width (proto, var_get_width (v));
}
const struct variable *const *
dict_get_split_vars (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->split;
}
size_t
dict_get_split_cnt (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->split_cnt;
}
/* Removes variable V, which must be in D, from D's set of split
variables. */
-void
+static void
dict_unset_split_var (struct dictionary *d, struct variable *v)
{
int orig_count;
dict_set_split_vars (struct dictionary *d,
struct variable *const *split, size_t cnt)
{
- assert (d != NULL);
assert (cnt == 0 || split != NULL);
d->split_cnt = cnt;
const char *
dict_get_label (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->label;
}
void
dict_set_label (struct dictionary *d, const char *label)
{
- assert (d != NULL);
-
free (d->label);
d->label = label != NULL ? xstrndup (label, 60) : NULL;
}
{
size_t i;
- assert (var != NULL);
assert (cnt > 0);
for (i = 0; i < cnt; i++)
assert (dict_contains_var (d, var[i]));
const struct vector *
dict_get_vector (const struct dictionary *d, size_t idx)
{
- assert (d != NULL);
assert (idx < d->vector_cnt);
return d->vector[idx];
size_t
dict_get_vector_cnt (const struct dictionary *d)
{
- assert (d != NULL);
-
return d->vector_cnt;
}
d->vector = NULL;
d->vector_cnt = 0;
}
+\f
+/* Multiple response sets. */
+
+/* Returns the multiple response set in DICT with index IDX, which must be
+ between 0 and the count returned by dict_get_n_mrsets(), exclusive. */
+const struct mrset *
+dict_get_mrset (const struct dictionary *dict, size_t idx)
+{
+ assert (idx < dict->n_mrsets);
+ return dict->mrsets[idx];
+}
+
+/* Returns the number of multiple response sets in DICT. */
+size_t
+dict_get_n_mrsets (const struct dictionary *dict)
+{
+ return dict->n_mrsets;
+}
+
+/* Looks for a multiple response set named NAME in DICT. If it finds one,
+ returns its index; otherwise, returns SIZE_MAX. */
+static size_t
+dict_lookup_mrset_idx (const struct dictionary *dict, const char *name)
+{
+ size_t i;
+
+ for (i = 0; i < dict->n_mrsets; i++)
+ if (!strcasecmp (name, dict->mrsets[i]->name))
+ return i;
+
+ return SIZE_MAX;
+}
+
+/* Looks for a multiple response set named NAME in DICT. If it finds one,
+ returns it; otherwise, returns NULL. */
+const struct mrset *
+dict_lookup_mrset (const struct dictionary *dict, const char *name)
+{
+ size_t idx = dict_lookup_mrset_idx (dict, name);
+ return idx != SIZE_MAX ? dict->mrsets[idx] : NULL;
+}
+
+/* Adds MRSET to DICT, replacing any existing set with the same name. Returns
+ true if a set was replaced, false if none existed with the specified name.
+
+ Ownership of MRSET is transferred to DICT. */
+bool
+dict_add_mrset (struct dictionary *dict, struct mrset *mrset)
+{
+ size_t idx;
+ assert (mrset_ok (mrset, dict));
+
+ idx = dict_lookup_mrset_idx (dict, mrset->name);
+ if (idx == SIZE_MAX)
+ {
+ dict->mrsets = xrealloc (dict->mrsets,
+ (dict->n_mrsets + 1) * sizeof *dict->mrsets);
+ dict->mrsets[dict->n_mrsets++] = mrset;
+ return true;
+ }
+ else
+ {
+ mrset_destroy (dict->mrsets[idx]);
+ dict->mrsets[idx] = mrset;
+ return false;
+ }
+}
+
+/* Looks for a multiple response set in DICT named NAME. If found, removes it
+ from DICT and returns true. If none is found, returns false without
+ modifying DICT.
+
+ Deleting one multiple response set causes the indexes of other sets within
+ DICT to change. */
+bool
+dict_delete_mrset (struct dictionary *dict, const char *name)
+{
+ size_t idx = dict_lookup_mrset_idx (dict, name);
+ if (idx != SIZE_MAX)
+ {
+ mrset_destroy (dict->mrsets[idx]);
+ dict->mrsets[idx] = dict->mrsets[--dict->n_mrsets];
+ return true;
+ }
+ else
+ return false;
+}
+
+/* Deletes all multiple response sets from DICT. */
+void
+dict_clear_mrsets (struct dictionary *dict)
+{
+ size_t i;
+
+ for (i = 0; i < dict->n_mrsets; i++)
+ mrset_destroy (dict->mrsets[i]);
+ free (dict->mrsets);
+ dict->mrsets = NULL;
+ dict->n_mrsets = 0;
+}
+
+/* Removes VAR, which must be in DICT, from DICT's multiple response sets. */
+static void
+dict_unset_mrset_var (struct dictionary *dict, struct variable *var)
+{
+ size_t i;
+
+ assert (dict_contains_var (dict, var));
+
+ for (i = 0; i < dict->n_mrsets; )
+ {
+ struct mrset *mrset = dict->mrsets[i];
+ size_t j;
+
+ for (j = 0; j < mrset->n_vars; )
+ if (mrset->vars[j] == var)
+ remove_element (mrset->vars, mrset->n_vars--,
+ sizeof *mrset->vars, j);
+ else
+ j++;
+
+ if (mrset->n_vars < 2)
+ {
+ mrset_destroy (mrset);
+ dict->mrsets[i] = dict->mrsets[--dict->n_mrsets];
+ }
+ else
+ i++;
+ }
+}
+\f
/* Returns D's attribute set. The caller may examine or modify
the attribute set, but must not destroy it. Destroying D or
calling dict_set_attributes for D will also destroy D's
struct attrset *
dict_get_attributes (const struct dictionary *d)
{
- return (struct attrset *) &d->attributes;
+ return CONST_CAST (struct attrset *, &d->attributes);
}
/* Replaces D's attributes set by a copy of ATTRS. */
{
if ( var_has_vardict (v))
{
- const struct vardict_info *vdi = var_get_vardict (v);
- struct dictionary *d = vdi->dict;
+ const struct vardict_info *vardict = var_get_vardict (v);
+ struct dictionary *d = vardict->dict;
if ( NULL == d)
return;
{
if ( var_has_vardict (v))
{
- const struct vardict_info *vdi = var_get_vardict (v);
+ const struct vardict_info *vardict = var_get_vardict (v);
struct dictionary *d;
- d = vdi->dict;
+ d = vardict->dict;
if (d->changed) d->changed (d, d->changed_data);
{
if ( var_has_vardict (v))
{
- const struct vardict_info *vdi = var_get_vardict (v);
+ const struct vardict_info *vardict = var_get_vardict (v);
struct dictionary *d;
- d = vdi->dict;
+ d = vardict->dict;
if (d->changed) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->var_display_width_changed )
d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data);
}
}
+\f
+/* Dictionary used to contain "internal variables". */
+static struct dictionary *internal_dict;
+
+/* Create a variable of the specified WIDTH to be used for internal
+ calculations only. The variable is assigned case index CASE_IDX. */
+struct variable *
+dict_create_internal_var (int case_idx, int width)
+{
+ if (internal_dict == NULL)
+ internal_dict = dict_create ();
+ for (;;)
+ {
+ static int counter = INT_MAX / 2;
+ struct variable *var;
+ char name[64];
+
+ if (++counter == INT_MAX)
+ counter = INT_MAX / 2;
+
+ sprintf (name, "$internal%d", counter);
+ var = dict_create_var (internal_dict, name, width);
+ if (var != NULL)
+ {
+ set_var_case_index (var, case_idx);
+ return var;
+ }
+ }
+}
+
+/* Destroys VAR, which must have been created with
+ dict_create_internal_var(). */
+void
+dict_destroy_internal_var (struct variable *var)
+{
+ if (var != NULL)
+ {
+ dict_delete_var (internal_dict, var);
+
+ /* Destroy internal_dict if it has no variables left, just so that
+ valgrind --leak-check --show-reachable won't show internal_dict. */
+ if (dict_get_var_cnt (internal_dict) == 0)
+ {
+ dict_destroy (internal_dict);
+ internal_dict = NULL;
+ }
+ }
+}
+\f
+int
+vardict_get_dict_index (const struct vardict_info *vardict)
+{
+ return vardict - vardict->dict->var;
+}
projects / pspp-builds.git / blobdiff