/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2007, 2009, 2010, 2011, 2012, 2013, 2014,
+ 2015, 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 "libpspp/pool.h"
#include "libpspp/str.h"
#include "libpspp/string-array.h"
+#include "libpspp/ll.h"
#include "gl/intprops.h"
#include "gl/minmax.h"
/* A dictionary. */
struct dictionary
{
- struct vardict_info *var; /* Variables. */
- size_t var_cnt, var_cap; /* Number of variables, capacity. */
+ int ref_cnt;
+ struct vardict_info *vars; /* Variables. */
+ size_t n_vars; /* Number of variables. */
+ size_t allocated_vars; /* Allocated space in 'vars'. */
struct caseproto *proto; /* Prototype for dictionary cases
(updated lazily). */
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. */
+ size_t n_splits; /* SPLIT FILE count. */
struct variable *weight; /* WEIGHT variable. */
struct variable *filter; /* FILTER variable. */
casenumber case_limit; /* Current case limit (N command). */
char *label; /* File label. */
struct string_array documents; /* Documents. */
struct vector **vector; /* Vectors of variables. */
- size_t vector_cnt; /* Number of vectors. */
+ size_t n_vectors; /* Number of vectors. */
struct attrset attributes; /* Custom attributes. */
struct mrset **mrsets; /* Multiple response sets. */
size_t n_mrsets; /* Number of multiple response sets. */
+ /* Whether variable names must be valid identifiers. Normally, this is
+ true, but sometimes a dictionary is prepared for external use
+ (e.g. output to a CSV file) where names don't have to be valid. */
+ bool names_must_be_ids;
+
char *encoding; /* Character encoding of string data */
const struct dict_callbacks *callbacks; /* Callbacks on dictionary
void *changed_data;
};
-static void dict_unset_split_var (struct dictionary *, struct variable *);
+static void dict_unset_split_var (struct dictionary *, struct variable *, bool);
static void dict_unset_mrset_var (struct dictionary *, struct variable *);
+/* Compares two double pointers to variables, which should point
+ to elements of a struct dictionary's `var' member array. */
+static int
+compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
+{
+ struct variable *const *a = a_;
+ struct variable *const *b = b_;
+
+ return *a < *b ? -1 : *a > *b;
+}
+
+static void
+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, bool skip_callbacks)
+{
+ struct variable *old = (d->callbacks && d->callbacks->var_changed
+ ? var_clone (vardict->var)
+ : NULL);
+
+ struct variable *var = vardict->var;
+ var_set_vardict (var, vardict);
+ hmap_insert_fast (&d->name_map, &vardict->name_node,
+ vardict->name_node.hash);
+
+ if (! skip_callbacks)
+ {
+ if (d->changed) d->changed (d, d->changed_data);
+ if (old)
+ {
+ d->callbacks->var_changed (d, var_get_dict_index (var), VAR_TRAIT_POSITION, old, d->cb_data);
+ var_unref (old);
+ }
+ }
+}
+
+/* Sets the case_index in V's vardict to CASE_INDEX. */
+static void
+set_var_case_index (struct variable *v, int case_index)
+{
+ 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->vars[i]);
+}
+
+/* Re-sets the dict_index in the dictionary variables with
+ indexes from FROM to TO (exclusive). */
+static void
+reindex_vars (struct dictionary *d, size_t from, size_t to, bool skip_callbacks)
+{
+ size_t i;
+
+ for (i = from; i < to; i++)
+ reindex_var (d, &d->vars[i], skip_callbacks);
+}
+
+\f
+
+/* Returns the encoding for data in dictionary D. The return value is a
+ nonnull string that contains an IANA character set name. */
const char *
dict_get_encoding (const struct dictionary *d)
{
dict_id_is_valid (const struct dictionary *dict, const char *id,
bool issue_error)
{
- return id_is_valid (id, dict->encoding, issue_error);
+ return (!dict->names_must_be_ids
+ || id_is_valid (id, dict->encoding, issue_error));
}
void
dict_dump (const struct dictionary *d)
{
int i;
- for (i = 0 ; i < d->var_cnt ; ++i )
+ for (i = 0 ; i < d->n_vars ; ++i)
{
- const struct variable *v = d->var[i].var;
+ const struct variable *v = d->vars[i].var;
printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n",
var_get_name (v),
var_get_dict_index (v),
struct dictionary *
dict_create (const char *encoding)
{
- struct dictionary *d = xzalloc (sizeof *d);
+ struct dictionary *d = XZALLOC (struct dictionary);
d->encoding = xstrdup (encoding);
+ d->names_must_be_ids = true;
hmap_init (&d->name_map);
attrset_init (&d->attributes);
+ d->ref_cnt = 1;
return d;
}
dictionary. If the new dictionary won't be used to access
cases produced with the old dictionary, then the new
dictionary's case indexes should be compacted with
- dict_compact_values to save space. */
+ dict_compact_values to save space.
+
+ Callbacks are not cloned. */
struct dictionary *
dict_clone (const struct dictionary *s)
{
size_t i;
d = dict_create (s->encoding);
+ dict_set_names_must_be_ids (d, dict_get_names_must_be_ids (s));
- /* Set the new dictionary's encoding early so that string length limitations
- are interpreted correctly. */
- if ( s->encoding)
- d->encoding = xstrdup (s->encoding);
-
- for (i = 0; i < s->var_cnt; i++)
+ for (i = 0; i < s->n_vars; i++)
{
- struct variable *sv = s->var[i].var;
+ struct variable *sv = s->vars[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++)
+ for (i = 0; i < var_get_n_short_names (sv); i++)
var_set_short_name (dv, i, var_get_short_name (sv, i));
var_get_vardict (dv)->case_index = var_get_vardict (sv)->case_index;
d->next_value_idx = s->next_value_idx;
- d->split_cnt = s->split_cnt;
- if (d->split_cnt > 0)
+ d->n_splits = s->n_splits;
+ if (d->n_splits > 0)
{
- d->split = xnmalloc (d->split_cnt, sizeof *d->split);
- for (i = 0; i < d->split_cnt; i++)
+ d->split = xnmalloc (d->n_splits, sizeof *d->split);
+ for (i = 0; i < d->n_splits; i++)
d->split[i] = dict_lookup_var_assert (d, var_get_name (s->split[i]));
}
dict_set_label (d, dict_get_label (s));
dict_set_documents (d, dict_get_documents (s));
- d->vector_cnt = s->vector_cnt;
- d->vector = xnmalloc (d->vector_cnt, sizeof *d->vector);
- for (i = 0; i < s->vector_cnt; i++)
+ d->n_vectors = s->n_vectors;
+ d->vector = xnmalloc (d->n_vectors, sizeof *d->vector);
+ for (i = 0; i < s->n_vectors; i++)
d->vector[i] = vector_clone (s->vector[i], s, d);
dict_set_attributes (d, dict_get_attributes (s));
return d;
}
+
+\f
+/* Returns the SPLIT FILE vars (see cmd_split_file()). Call
+ dict_get_n_splits() to determine how many SPLIT FILE vars
+ there are. Returns a null pointer if and only if there are no
+ SPLIT FILE vars. */
+const struct variable *const *
+dict_get_split_vars (const struct dictionary *d)
+{
+ return d->split;
+}
+
+/* Returns the number of SPLIT FILE vars. */
+size_t
+dict_get_n_splits (const struct dictionary *d)
+{
+ return d->n_splits;
+}
+
+/* Removes variable V, which must be in D, from D's set of split
+ variables. */
+static void
+dict_unset_split_var (struct dictionary *d, struct variable *v, bool skip_callbacks)
+{
+ int orig_count;
+
+ assert (dict_contains_var (d, v));
+
+ orig_count = d->n_splits;
+ d->n_splits = remove_equal (d->split, d->n_splits, sizeof *d->split,
+ &v, compare_var_ptrs, NULL);
+ if (orig_count != d->n_splits && !skip_callbacks)
+ {
+ if (d->changed) d->changed (d, d->changed_data);
+ /* We changed the set of split variables so invoke the
+ callback. */
+ if (d->callbacks && d->callbacks->split_changed)
+ d->callbacks->split_changed (d, d->cb_data);
+ }
+}
+
+
+/* Sets N split vars SPLIT in dictionary D. */
+static void
+dict_set_split_vars__ (struct dictionary *d,
+ struct variable *const *split, size_t n,
+ bool skip_callbacks)
+{
+ assert (n == 0 || split != NULL);
+
+ d->n_splits = n;
+ if (n > 0)
+ {
+ d->split = xnrealloc (d->split, n, sizeof *d->split) ;
+ memcpy (d->split, split, n * sizeof *d->split);
+ }
+ else
+ {
+ free (d->split);
+ d->split = NULL;
+ }
+
+ if (!skip_callbacks)
+ {
+ if (d->changed) d->changed (d, d->changed_data);
+ if (d->callbacks && d->callbacks->split_changed)
+ d->callbacks->split_changed (d, d->cb_data);
+ }
+}
+
+/* Sets N split vars SPLIT in dictionary D. */
+void
+dict_set_split_vars (struct dictionary *d,
+ struct variable *const *split, size_t n)
+{
+ dict_set_split_vars__ (d, split, n, false);
+}
+
+\f
+
+/* Deletes variable V from dictionary D and frees V.
+
+ This is a very bad idea if there might be any pointers to V
+ from outside D. In general, no variable in the active dataset's
+ dictionary should be deleted when any transformations are
+ active on the dictionary's dataset, because those
+ transformations might reference the deleted variable. The
+ safest time to delete a variable is just after a procedure has
+ been executed, as done by DELETE VARIABLES.
+
+ Pointers to V within D are not a problem, because
+ dict_delete_var() knows to remove V from split variables,
+ weights, filters, etc. */
+static void
+dict_delete_var__ (struct dictionary *d, struct variable *v, bool skip_callbacks)
+{
+ int dict_index = var_get_dict_index (v);
+ const int case_index = var_get_case_index (v);
+
+ assert (dict_contains_var (d, v));
+
+ dict_unset_split_var (d, v, skip_callbacks);
+ dict_unset_mrset_var (d, v);
+
+ if (d->weight == v)
+ dict_set_weight (d, NULL);
+
+ if (d->filter == v)
+ dict_set_filter (d, NULL);
+
+ dict_clear_vectors (d);
+
+ /* Remove V from var array. */
+ unindex_vars (d, dict_index, d->n_vars);
+ remove_element (d->vars, d->n_vars, sizeof *d->vars, dict_index);
+ d->n_vars--;
+
+ /* Update dict_index for each affected variable. */
+ reindex_vars (d, dict_index, d->n_vars, skip_callbacks);
+
+ /* Free memory. */
+ var_clear_vardict (v);
+
+ if (! skip_callbacks)
+ {
+ if (d->changed) d->changed (d, d->changed_data);
+ if (d->callbacks && d->callbacks->var_deleted)
+ d->callbacks->var_deleted (d, v, dict_index, case_index, d->cb_data);
+ }
+
+ invalidate_proto (d);
+ var_unref (v);
+}
+
+/* Deletes variable V from dictionary D and frees V.
+
+ This is a very bad idea if there might be any pointers to V
+ from outside D. In general, no variable in the active dataset's
+ dictionary should be deleted when any transformations are
+ active on the dictionary's dataset, because those
+ transformations might reference the deleted variable. The
+ safest time to delete a variable is just after a procedure has
+ been executed, as done by DELETE VARIABLES.
+
+ Pointers to V within D are not a problem, because
+ dict_delete_var() knows to remove V from split variables,
+ weights, filters, etc. */
+void
+dict_delete_var (struct dictionary *d, struct variable *v)
+{
+ dict_delete_var__ (d, v, false);
+}
+
+
+/* Deletes the COUNT variables listed in VARS from D. This is
+ unsafe; see the comment on dict_delete_var() for details. */
+void
+dict_delete_vars (struct dictionary *d,
+ struct variable *const *vars, size_t count)
+{
+ /* FIXME: this can be done in O(count) time, but this algorithm
+ is O(count**2). */
+ assert (count == 0 || vars != NULL);
+
+ while (count-- > 0)
+ dict_delete_var (d, *vars++);
+}
+
+/* Deletes the COUNT variables in D starting at index IDX. This
+ is unsafe; see the comment on dict_delete_var() for
+ details. Deleting consecutive vars will result in less callbacks
+ compared to iterating over dict_delete_var.
+ A simple while loop over dict_delete_var will
+ produce (d->n_vars - IDX) * COUNT variable changed callbacks
+ plus COUNT variable delete callbacks.
+ This here produces d->n_vars - IDX variable changed callbacks
+ plus COUNT variable delete callbacks. */
+void
+dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
+{
+ assert (idx + count <= d->n_vars);
+
+ /* We need to store the variable and the corresponding case_index
+ for the delete callbacks later. We store them in a linked list.*/
+ struct delvar {
+ struct ll ll;
+ struct variable *var;
+ int case_index;
+ };
+ struct ll_list list = LL_INITIALIZER (list);
+
+ for (size_t i = idx; i < idx + count; i++)
+ {
+ struct delvar *dv = xmalloc (sizeof (struct delvar));
+ assert (dv);
+ struct variable *v = d->vars[i].var;
+
+ dict_unset_split_var (d, v, false);
+ dict_unset_mrset_var (d, v);
+
+ if (d->weight == v)
+ dict_set_weight (d, NULL);
+
+ if (d->filter == v)
+ dict_set_filter (d, NULL);
+
+ dv->var = v;
+ dv->case_index = var_get_case_index (v);
+ ll_push_tail (&list, (struct ll *)dv);
+ }
+
+ dict_clear_vectors (d);
+
+ /* Remove variables from var array. */
+ unindex_vars (d, idx, d->n_vars);
+ remove_range (d->vars, d->n_vars, sizeof *d->vars, idx, count);
+ d->n_vars -= count;
+
+ /* Reindexing will result variable-changed callback */
+ reindex_vars (d, idx, d->n_vars, false);
+
+ invalidate_proto (d);
+ if (d->changed) d->changed (d, d->changed_data);
+
+ /* Now issue the variable delete callbacks and delete
+ the variables. The vardict is not valid at this point
+ anymore. That is the reason why we stored the
+ caseindex before reindexing. */
+ for (size_t vi = idx; vi < idx + count; vi++)
+ {
+ struct delvar *dv = (struct delvar *) ll_pop_head (&list);
+ var_clear_vardict (dv->var);
+ if (d->callbacks && d->callbacks->var_deleted)
+ d->callbacks->var_deleted (d, dv->var, vi, dv->case_index, d->cb_data);
+ var_unref (dv->var);
+ free (dv);
+ }
+}
+
+/* Deletes scratch variables from dictionary D. */
+void
+dict_delete_scratch_vars (struct dictionary *d)
+{
+ int i;
+
+ /* FIXME: this can be done in O(count) time, but this algorithm
+ is O(count**2). */
+ for (i = 0; i < d->n_vars;)
+ if (var_get_dict_class (d->vars[i].var) == DC_SCRATCH)
+ dict_delete_var (d, d->vars[i].var);
+ else
+ i++;
+}
+
+\f
+
/* Clears the contents from a dictionary without destroying the
dictionary itself. */
-void
-dict_clear (struct dictionary *d)
+static void
+dict_clear__ (struct dictionary *d, bool skip_callbacks)
{
/* FIXME? Should we really clear case_limit, label, documents?
Others are necessarily cleared by deleting all the variables.*/
- while (d->var_cnt > 0 )
+ while (d->n_vars > 0)
{
- dict_delete_var (d, d->var[d->var_cnt - 1].var);
+ dict_delete_var__ (d, d->vars[d->n_vars - 1].var, skip_callbacks);
}
- free (d->var);
- d->var = NULL;
- d->var_cnt = d->var_cap = 0;
+ free (d->vars);
+ d->vars = NULL;
+ d->n_vars = d->allocated_vars = 0;
invalidate_proto (d);
hmap_clear (&d->name_map);
d->next_value_idx = 0;
- dict_set_split_vars (d, NULL, 0);
- dict_set_weight (d, NULL);
- dict_set_filter (d, NULL);
+ dict_set_split_vars__ (d, NULL, 0, skip_callbacks);
+
+ if (skip_callbacks)
+ {
+ d->weight = NULL;
+ d->filter = NULL;
+ }
+ else
+ {
+ dict_set_weight (d, NULL);
+ dict_set_filter (d, NULL);
+ }
d->case_limit = 0;
free (d->label);
d->label = NULL;
attrset_clear (&d->attributes);
}
-/* Destroys the aux data for every variable in D, by calling
- var_clear_aux() for each variable. */
+/* Clears the contents from a dictionary without destroying the
+ dictionary itself. */
void
-dict_clear_aux (struct dictionary *d)
+dict_clear (struct dictionary *d)
{
- int i;
-
- for (i = 0; i < d->var_cnt; i++)
- var_clear_aux (d->var[i].var);
+ dict_clear__ (d, false);
}
/* Clears a dictionary and destroys it. */
+static void
+_dict_destroy (struct dictionary *d)
+{
+ /* In general, we don't want callbacks occurring, if the dictionary
+ is being destroyed */
+ d->callbacks = NULL ;
+
+ dict_clear__ (d, true);
+ string_array_destroy (&d->documents);
+ hmap_destroy (&d->name_map);
+ attrset_destroy (&d->attributes);
+ dict_clear_mrsets (d);
+ free (d->encoding);
+ free (d);
+}
+
+struct dictionary *
+dict_ref (struct dictionary *d)
+{
+ d->ref_cnt++;
+ return d;
+}
+
void
-dict_destroy (struct dictionary *d)
+dict_unref (struct dictionary *d)
{
- if (d != NULL)
- {
- /* In general, we don't want callbacks occuring, if the dictionary
- is being destroyed */
- d->callbacks = NULL ;
-
- dict_clear (d);
- hmap_destroy (&d->name_map);
- attrset_destroy (&d->attributes);
- dict_clear_mrsets (d);
- free (d->encoding);
- free (d);
- }
+ if (d == NULL)
+ return;
+ d->ref_cnt--;
+ assert (d->ref_cnt >= 0);
+ if (d->ref_cnt == 0)
+ _dict_destroy (d);
}
/* Returns the number of variables in D. */
size_t
-dict_get_var_cnt (const struct dictionary *d)
+dict_get_n_vars (const struct dictionary *d)
{
- return d->var_cnt;
+ return d->n_vars;
}
/* Returns the variable in D with dictionary index IDX, which
must be between 0 and the count returned by
- dict_get_var_cnt(), exclusive. */
+ dict_get_n_vars(), exclusive. */
struct variable *
dict_get_var (const struct dictionary *d, size_t idx)
{
- assert (idx < d->var_cnt);
+ assert (idx < d->n_vars);
- return d->var[idx].var;
+ return d->vars[idx].var;
}
-/* Sets *VARS to an array of pointers to variables in D and *CNT
+/* Sets *VARS to an array of pointers to variables in D and *N
to the number of variables in *D. All variables are returned
except for those, if any, in the classes indicated by EXCLUDE.
(There is no point in putting DC_SYSTEM in EXCLUDE as
dictionaries never include system variables.) */
void
dict_get_vars (const struct dictionary *d, const struct variable ***vars,
- size_t *cnt, enum dict_class exclude)
+ size_t *n, enum dict_class exclude)
{
- dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude);
+ dict_get_vars_mutable (d, (struct variable ***) vars, n, exclude);
}
-/* Sets *VARS to an array of pointers to variables in D and *CNT
+/* Sets *VARS to an array of pointers to variables in D and *N
to the number of variables in *D. All variables are returned
except for those, if any, in the classes indicated by EXCLUDE.
(There is no point in putting DC_SYSTEM in EXCLUDE as
dictionaries never include system variables.) */
void
dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
- size_t *cnt, enum dict_class exclude)
+ size_t *n, enum dict_class exclude)
{
size_t count;
size_t i;
assert (exclude == (exclude & DC_ALL));
count = 0;
- for (i = 0; i < d->var_cnt; i++)
+ for (i = 0; i < d->n_vars; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i].var);
+ enum dict_class class = var_get_dict_class (d->vars[i].var);
if (!(class & exclude))
count++;
}
*vars = xnmalloc (count, sizeof **vars);
- *cnt = 0;
- for (i = 0; i < d->var_cnt; i++)
+ *n = 0;
+ for (i = 0; i < d->n_vars; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i].var);
+ enum dict_class class = var_get_dict_class (d->vars[i].var);
if (!(class & exclude))
- (*vars)[(*cnt)++] = d->var[i].var;
+ (*vars)[(*n)++] = d->vars[i].var;
}
- assert (*cnt == count);
+ assert (*n == count);
}
static struct variable *
-add_var (struct dictionary *d, struct variable *v)
+add_var_with_case_index (struct dictionary *d, struct variable *v,
+ int case_index)
{
struct vardict_info *vardict;
+ assert (case_index >= d->next_value_idx);
+
/* Update dictionary. */
- if (d->var_cnt >= d->var_cap)
+ if (d->n_vars >= d->allocated_vars)
{
size_t i;
- d->var = x2nrealloc (d->var, &d->var_cap, sizeof *d->var);
+ d->vars = x2nrealloc (d->vars, &d->allocated_vars, sizeof *d->vars);
hmap_clear (&d->name_map);
- for (i = 0; i < d->var_cnt; i++)
+ for (i = 0; i < d->n_vars; 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);
+ var_set_vardict (d->vars[i].var, &d->vars[i]);
+ hmap_insert_fast (&d->name_map, &d->vars[i].name_node,
+ d->vars[i].name_node.hash);
}
}
- vardict = &d->var[d->var_cnt++];
+ vardict = &d->vars[d->n_vars++];
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;
+ utf8_hash_case_string (var_get_name (v), 0));
+ vardict->case_index = case_index;
var_set_vardict (v, vardict);
- if ( d->changed ) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->var_added )
+ if (d->changed) d->changed (d, d->changed_data);
+ if (d->callbacks && d->callbacks->var_added)
d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data);
- d->next_value_idx++;
invalidate_proto (d);
+ d->next_value_idx = case_index + 1;
+
+ return v;
+}
- return v;
+static struct variable *
+add_var (struct dictionary *d, struct variable *v)
+{
+ return add_var_with_case_index (d, v, d->next_value_idx);
}
/* Creates and returns a new variable in D with the given NAME
return add_var (d, new_var);
}
+struct variable *
+dict_clone_var_in_place_assert (struct dictionary *d,
+ const struct variable *old_var)
+{
+ assert (dict_lookup_var (d, var_get_name (old_var)) == NULL);
+ return add_var_with_case_index (d, var_clone (old_var),
+ var_get_case_index (old_var));
+}
+
/* Returns the variable named NAME in D, or a null pointer if no
variable has that name. */
struct variable *
struct vardict_info *vardict;
HMAP_FOR_EACH_WITH_HASH (vardict, struct vardict_info, name_node,
- hash_case_string (name, 0), &d->name_map)
+ utf8_hash_case_string (name, 0), &d->name_map)
{
struct variable *var = vardict->var;
- if (!strcasecmp (var_get_name (var), name))
+ if (!utf8_strcasecmp (var_get_name (var), name))
return var;
}
&& vardict_get_dictionary (var_get_vardict (v)) == d);
}
-/* Compares two double pointers to variables, which should point
- to elements of a struct dictionary's `var' member array. */
-static int
-compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED)
-{
- struct variable *const *a = a_;
- struct variable *const *b = b_;
-
- return *a < *b ? -1 : *a > *b;
-}
-
-static void
-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 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, 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)
-{
- 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
- indexes from FROM to TO (exclusive). */
-static void
-reindex_vars (struct dictionary *d, size_t from, size_t to)
-{
- size_t i;
-
- for (i = from; i < to; i++)
- reindex_var (d, &d->var[i]);
-}
-
-/* Deletes variable V from dictionary D and frees V.
-
- This is a very bad idea if there might be any pointers to V
- from outside D. In general, no variable in the active dataset's
- dictionary should be deleted when any transformations are
- active on the dictionary's dataset, because those
- transformations might reference the deleted variable. The
- safest time to delete a variable is just after a procedure has
- been executed, as done by DELETE VARIABLES.
-
- Pointers to V within D are not a problem, because
- dict_delete_var() knows to remove V from split variables,
- weights, filters, etc. */
-void
-dict_delete_var (struct dictionary *d, struct variable *v)
-{
- int dict_index = var_get_dict_index (v);
- const int case_index = var_get_case_index (v);
- const int width = var_get_width (v);
-
- assert (dict_contains_var (d, v));
-
- /* Delete aux data. */
- 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);
-
- if (d->filter == v)
- dict_set_filter (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);
-
- /* Free memory. */
- var_clear_vardict (v);
- var_destroy (v);
-
- if ( d->changed ) d->changed (d, d->changed_data);
-
- invalidate_proto (d);
- if (d->callbacks && d->callbacks->var_deleted )
- d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data);
-}
-
-/* Deletes the COUNT variables listed in VARS from D. This is
- unsafe; see the comment on dict_delete_var() for details. */
-void
-dict_delete_vars (struct dictionary *d,
- struct variable *const *vars, size_t count)
-{
- /* FIXME: this can be done in O(count) time, but this algorithm
- is O(count**2). */
- assert (count == 0 || vars != NULL);
-
- while (count-- > 0)
- dict_delete_var (d, *vars++);
-}
-
-/* Deletes the COUNT variables in D starting at index IDX. This
- is unsafe; see the comment on dict_delete_var() for
- details. */
-void
-dict_delete_consecutive_vars (struct dictionary *d, size_t idx, size_t count)
-{
- /* FIXME: this can be done in O(count) time, but this algorithm
- is O(count**2). */
- assert (idx + count <= d->var_cnt);
-
- while (count-- > 0)
- dict_delete_var (d, d->var[idx].var);
-}
-
-/* Deletes scratch variables from dictionary D. */
-void
-dict_delete_scratch_vars (struct dictionary *d)
-{
- int i;
-
- /* FIXME: this can be done in O(count) time, but this algorithm
- is O(count**2). */
- for (i = 0; i < d->var_cnt; )
- if (var_get_dict_class (d->var[i].var) == DC_SCRATCH)
- dict_delete_var (d, d->var[i].var);
- else
- i++;
-}
-
/* Moves V to 0-based position IDX in D. Other variables in D,
if any, retain their relative positions. Runs in time linear
in the distance moved. */
{
size_t old_index = var_get_dict_index (v);
- assert (new_index < d->var_cnt);
+ assert (new_index < d->n_vars);
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);
+ move_element (d->vars, d->n_vars, sizeof *d->vars, old_index, new_index);
+ reindex_vars (d, MIN (old_index, new_index), MAX (old_index, new_index) + 1, false);
}
/* Reorders the variables in D, placing the COUNT variables
size_t i;
assert (count == 0 || order != NULL);
- assert (count <= d->var_cnt);
+ assert (count <= d->n_vars);
- new_var = xnmalloc (d->var_cap, sizeof *new_var);
+ new_var = xnmalloc (d->allocated_vars, sizeof *new_var);
/* Add variables in ORDER to new_var. */
for (i = 0; i < count; i++)
}
/* Add remaining variables to new_var. */
- for (i = 0; i < d->var_cnt; i++)
- if (d->var[i].dict != NULL)
- new_var[count++] = d->var[i];
- assert (count == d->var_cnt);
+ for (i = 0; i < d->n_vars; i++)
+ if (d->vars[i].dict != NULL)
+ new_var[count++] = d->vars[i];
+ assert (count == d->n_vars);
/* Replace old vardicts by new ones. */
- free (d->var);
- d->var = new_var;
+ free (d->vars);
+ d->vars = new_var;
hmap_clear (&d->name_map);
- reindex_vars (d, 0, d->var_cnt);
+ reindex_vars (d, 0, d->n_vars, false);
}
/* Changes the name of variable V that is currently in a dictionary to
struct vardict_info *vardict = var_get_vardict (v);
var_clear_vardict (v);
var_set_name (v, new_name);
- vardict->name_node.hash = hash_case_string (new_name, 0);
+ vardict->name_node.hash = utf8_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
- a variable named NEW_NAME is already in D, except that
- NEW_NAME may be the same as V's existing name. */
-void
-dict_rename_var (struct dictionary *d, struct variable *v,
- const char *new_name)
+/* Tries to changes the name of V in D to name NEW_NAME. Returns true if
+ successful, false if a variable (other than V) with the given name already
+ exists in D. */
+bool
+dict_try_rename_var (struct dictionary *d, struct variable *v,
+ const char *new_name)
{
- assert (!strcasecmp (var_get_name (v), new_name)
- || dict_lookup_var (d, new_name) == NULL);
+ struct variable *conflict = dict_lookup_var (d, new_name);
+ if (conflict && v != conflict)
+ return false;
+ struct variable *old = var_clone (v);
unindex_var (d, var_get_vardict (v));
rename_var (v, new_name);
- reindex_var (d, var_get_vardict (v));
+ reindex_var (d, var_get_vardict (v), false);
if (settings_get_algorithm () == ENHANCED)
var_clear_short_names (v);
- if ( d->changed ) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->var_changed )
- d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
+ if (d->changed) d->changed (d, d->changed_data);
+ if (d->callbacks && d->callbacks->var_changed)
+ d->callbacks->var_changed (d, var_get_dict_index (v), VAR_TRAIT_NAME, old, d->cb_data);
+
+ var_unref (old);
+
+ return true;
+}
+
+/* Changes the name of V in D to name NEW_NAME. Assert-fails if
+ a variable named NEW_NAME is already in D, except that
+ NEW_NAME may be the same as V's existing name. */
+void
+dict_rename_var (struct dictionary *d, struct variable *v,
+ const char *new_name)
+{
+ bool ok UNUSED = dict_try_rename_var (d, v, new_name);
+ assert (ok);
}
/* Renames COUNT variables specified in VARS to the names given
for (i = 0; i < count; i++)
{
rename_var (vars[i], old_names[i]);
- reindex_var (d, var_get_vardict (vars[i]));
+ reindex_var (d, var_get_vardict (vars[i]), false);
}
pool_destroy (pool);
return false;
}
- reindex_var (d, var_get_vardict (vars[i]));
+ reindex_var (d, var_get_vardict (vars[i]), false);
}
/* Clear short names. */
size_t ofs;
int mblen;
+ if (hint_len > ID_MAX_LEN)
+ hint_len = ID_MAX_LEN;
+
/* The allocation size here is OK: characters that are copied directly fit
OK, and characters that are not copied directly are replaced by a single
'_' byte. If u8_mbtouc() replaces bad input by 0xfffd, then that will get
char *name;
suffix[0] = '_';
- if (!str_format_26adic (i + 1, &suffix[1], sizeof suffix - 1))
+ if (!str_format_26adic (i + 1, true, &suffix[1], sizeof suffix - 1))
NOT_REACHED ();
name = utf8_encoding_concat (root, suffix, dict->encoding, 64);
if (hinted_name != NULL)
return hinted_name;
}
+
return make_numeric_name (dict, num_start);
}
+/* Returns whether variable names must be valid identifiers. Normally, this is
+ true, but sometimes a dictionary is prepared for external use (e.g. output
+ to a CSV file) where names don't have to be valid. */
+bool
+dict_get_names_must_be_ids (const struct dictionary *d)
+{
+ return d->names_must_be_ids;
+}
+
+/* Sets whether variable names must be valid identifiers. Normally, this is
+ true, but sometimes a dictionary is prepared for external use (e.g. output
+ to a CSV file) where names don't have to be valid.
+
+ Changing this setting from false to true doesn't make the dictionary check
+ all the existing variable names, so it can cause an invariant violation. */
+void
+dict_set_names_must_be_ids (struct dictionary *d, bool names_must_be_ids)
+{
+ d->names_must_be_ids = names_must_be_ids;
+}
+
/* Returns the weighting variable in dictionary D, or a null
pointer if the dictionary is unweighted. */
struct variable *
else
{
double w = case_num (c, d->weight);
- if (w < 0.0 || var_is_num_missing (d->weight, w, MV_ANY))
- 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;
+
+ return var_force_valid_weight (d->weight, w, warn_on_invalid);
}
}
+/* Returns the format to use for weights. */
+const struct fmt_spec *
+dict_get_weight_format (const struct dictionary *d)
+{
+ return d->weight ? var_get_print_format (d->weight) : &F_8_0;
+}
+
/* Sets the weighting variable of D to V, or turning off
weighting if V is a null pointer. */
void
d->weight = v;
if (d->changed) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->weight_changed )
+ if (d->callbacks && d->callbacks->weight_changed)
d->callbacks->weight_changed (d,
- v ? var_get_dict_index (v) : -1,
- d->cb_data);
+ v ? var_get_dict_index (v) : -1,
+ d->cb_data);
}
/* Returns the filter variable in dictionary D (see cmd_filter())
d->filter = v;
if (d->changed) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->filter_changed )
+ if (d->callbacks && d->callbacks->filter_changed)
d->callbacks->filter_changed (d,
- v ? var_get_dict_index (v) : -1,
- d->cb_data);
+ v ? var_get_dict_index (v) : -1,
+ d->cb_data);
}
/* Returns the case limit for dictionary D, or zero if the number
size_t i;
d->proto = caseproto_create ();
- d->proto = caseproto_reserve (d->proto, d->var_cnt);
- for (i = 0; i < d->var_cnt; i++)
+ d->proto = caseproto_reserve (d->proto, d->n_vars);
+ for (i = 0; i < d->n_vars; i++)
d->proto = caseproto_set_width (d->proto,
- var_get_case_index (d->var[i].var),
- var_get_width (d->var[i].var));
+ var_get_case_index (d->vars[i].var),
+ var_get_width (d->vars[i].var));
}
return d->proto;
}
size_t i;
d->next_value_idx = 0;
- for (i = 0; i < d->var_cnt; i++)
+ for (i = 0; i < d->n_vars; i++)
{
- struct variable *v = d->var[i].var;
+ struct variable *v = d->vars[i].var;
set_var_case_index (v, d->next_value_idx++);
}
invalidate_proto (d);
size_t
dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
{
- size_t i;
- size_t cnt;
-
assert ((exclude_classes & ~((1u << DC_ORDINARY)
| (1u << DC_SYSTEM)
| (1u << DC_SCRATCH))) == 0);
- cnt = 0;
- for (i = 0; i < d->var_cnt; i++)
+ size_t n = 0;
+ for (size_t i = 0; i < d->n_vars; i++)
{
- enum dict_class class = var_get_dict_class (d->var[i].var);
+ enum dict_class class = var_get_dict_class (d->vars[i].var);
if (!(exclude_classes & (1u << class)))
- cnt++;
+ n++;
}
- return cnt;
+ return n;
}
/* Returns the case prototype that would result after deleting
| (1u << DC_SCRATCH))) == 0);
proto = caseproto_create ();
- for (i = 0; i < d->var_cnt; i++)
+ for (i = 0; i < d->n_vars; i++)
{
- struct variable *v = d->var[i].var;
+ struct variable *v = d->vars[i].var;
if (!(exclude_classes & (1u << var_get_dict_class (v))))
proto = caseproto_add_width (proto, var_get_width (v));
}
return proto;
}
-\f
-/* Returns the SPLIT FILE vars (see cmd_split_file()). Call
- dict_get_split_cnt() to determine how many SPLIT FILE vars
- there are. Returns a null pointer if and only if there are no
- SPLIT FILE vars. */
-const struct variable *const *
-dict_get_split_vars (const struct dictionary *d)
-{
- return d->split;
-}
-
-/* Returns the number of SPLIT FILE vars. */
-size_t
-dict_get_split_cnt (const struct dictionary *d)
-{
- return d->split_cnt;
-}
-
-/* Removes variable V, which must be in D, from D's set of split
- variables. */
-static void
-dict_unset_split_var (struct dictionary *d, struct variable *v)
-{
- int orig_count;
-
- assert (dict_contains_var (d, v));
-
- orig_count = d->split_cnt;
- d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
- &v, compare_var_ptrs, NULL);
- if (orig_count != d->split_cnt)
- {
- if (d->changed) d->changed (d, d->changed_data);
- /* We changed the set of split variables so invoke the
- callback. */
- if (d->callbacks && d->callbacks->split_changed)
- d->callbacks->split_changed (d, d->cb_data);
- }
-}
-
-/* Sets CNT split vars SPLIT in dictionary D. */
-void
-dict_set_split_vars (struct dictionary *d,
- struct variable *const *split, size_t cnt)
-{
- assert (cnt == 0 || split != NULL);
-
- d->split_cnt = cnt;
- if ( cnt > 0 )
- {
- d->split = xnrealloc (d->split, cnt, sizeof *d->split) ;
- memcpy (d->split, split, cnt * sizeof *d->split);
- }
- else
- {
- free (d->split);
- d->split = NULL;
- }
-
- if (d->changed) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->split_changed )
- d->callbacks->split_changed (d, d->cb_data);
-}
-
/* Returns the file label for D, or a null pointer if D is
unlabeled (see cmd_file_label()). */
const char *
return d->label;
}
-/* Sets D's file label to LABEL, truncating it to a maximum of 60
- characters.
+/* Sets D's file label to LABEL, truncating it to at most 60 bytes in D's
+ encoding.
Removes D's label if LABEL is null or the empty string. */
void
dict_set_label (struct dictionary *d, const char *label)
{
free (d->label);
- d->label = label != NULL && label[0] != '\0' ? xstrndup (label, 60) : NULL;
+ if (label == NULL || label[0] == '\0')
+ d->label = NULL;
+ else
+ d->label = utf8_encoding_trunc (label, d->encoding, 60);
}
/* Returns the documents for D, as an UTF-8 encoded string_array. The
void
dict_set_documents (struct dictionary *d, const struct string_array *new_docs)
{
- size_t i;
+ /* Swap out the old documents, instead of destroying them immediately, to
+ allow the new documents to include pointers into the old ones. */
+ struct string_array old_docs = STRING_ARRAY_INITIALIZER;
+ string_array_swap (&d->documents, &old_docs);
- dict_clear_documents (d);
-
- for (i = 0; i < new_docs->n; i++)
+ for (size_t i = 0; i < new_docs->n; i++)
dict_add_document_line (d, new_docs->strings[i], false);
+
+ string_array_destroy (&old_docs);
}
/* Replaces the documents for D by UTF-8 encoded string NEW_DOCS, dividing it
const char *s;
dict_clear_documents (d);
- for (s = new_docs; *s != '\0'; )
+ for (s = new_docs; *s != '\0';)
{
size_t len = strcspn (s, "\n");
char *line = xmemdup0 (s, len);
truncated = line[trunc_len] != '\0';
if (truncated && issue_warning)
{
- /* Note to translators: "bytes" is correct, not characters */
+ /* TRANSLATORS: "bytes" is correct, not characters due to UTF encoding */
msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
}
/* Returns the number of document lines in dictionary D. */
size_t
-dict_get_document_line_cnt (const struct dictionary *d)
+dict_get_document_n_lines (const struct dictionary *d)
{
return d->documents.n;
}
return d->documents.strings[idx];
}
-/* Creates in D a vector named NAME that contains the CNT
+/* Creates in D a vector named NAME that contains the N
variables in VAR. Returns true if successful, or false if a
vector named NAME already exists in D. */
bool
dict_create_vector (struct dictionary *d,
const char *name,
- struct variable **var, size_t cnt)
+ struct variable **var, size_t n)
{
- size_t i;
-
- assert (cnt > 0);
- for (i = 0; i < cnt; i++)
+ assert (n > 0);
+ for (size_t i = 0; i < n; i++)
assert (dict_contains_var (d, var[i]));
if (dict_lookup_vector (d, name) == NULL)
{
- d->vector = xnrealloc (d->vector, d->vector_cnt + 1, sizeof *d->vector);
- d->vector[d->vector_cnt++] = vector_create (name, var, cnt);
+ d->vector = xnrealloc (d->vector, d->n_vectors + 1, sizeof *d->vector);
+ d->vector[d->n_vectors++] = vector_create (name, var, n);
return true;
}
else
return false;
}
-/* Creates in D a vector named NAME that contains the CNT
+/* Creates in D a vector named NAME that contains the N
variables in VAR. A vector named NAME must not already exist
in D. */
void
dict_create_vector_assert (struct dictionary *d,
const char *name,
- struct variable **var, size_t cnt)
+ struct variable **var, size_t n)
{
assert (dict_lookup_vector (d, name) == NULL);
- dict_create_vector (d, name, var, cnt);
+ dict_create_vector (d, name, var, n);
}
/* Returns the vector in D with index IDX, which must be less
- than dict_get_vector_cnt (D). */
+ than dict_get_n_vectors (D). */
const struct vector *
dict_get_vector (const struct dictionary *d, size_t idx)
{
- assert (idx < d->vector_cnt);
+ assert (idx < d->n_vectors);
return d->vector[idx];
}
/* Returns the number of vectors in D. */
size_t
-dict_get_vector_cnt (const struct dictionary *d)
+dict_get_n_vectors (const struct dictionary *d)
{
- return d->vector_cnt;
+ return d->n_vectors;
}
/* Looks up and returns the vector within D with the given
dict_lookup_vector (const struct dictionary *d, const char *name)
{
size_t i;
- for (i = 0; i < d->vector_cnt; i++)
- if (!strcasecmp (vector_get_name (d->vector[i]), name))
+ for (i = 0; i < d->n_vectors; i++)
+ if (!utf8_strcasecmp (vector_get_name (d->vector[i]), name))
return d->vector[i];
return NULL;
}
{
size_t i;
- for (i = 0; i < d->vector_cnt; i++)
+ for (i = 0; i < d->n_vectors; i++)
vector_destroy (d->vector[i]);
free (d->vector);
d->vector = NULL;
- d->vector_cnt = 0;
+ d->n_vectors = 0;
}
\f
/* Multiple response sets. */
size_t i;
for (i = 0; i < dict->n_mrsets; i++)
- if (!strcasecmp (name, dict->mrsets[i]->name))
+ if (!utf8_strcasecmp (name, dict->mrsets[i]->name))
return i;
return SIZE_MAX;
assert (dict_contains_var (dict, var));
- for (i = 0; i < dict->n_mrsets; )
+ for (i = 0; i < dict->n_mrsets;)
{
struct mrset *mrset = dict->mrsets[i];
size_t j;
- for (j = 0; j < mrset->n_vars; )
+ for (j = 0; j < mrset->n_vars;)
if (mrset->vars[j] == var)
remove_element (mrset->vars, mrset->n_vars--,
sizeof *mrset->vars, j);
calling dict_set_attributes for D will also destroy D's
attribute set. */
struct attrset *
-dict_get_attributes (const struct dictionary *d)
+dict_get_attributes (const struct dictionary *d)
{
return CONST_CAST (struct attrset *, &d->attributes);
}
/* Returns true if D has at least one attribute in its attribute
set, false if D's attribute set is empty. */
bool
-dict_has_attributes (const struct dictionary *d)
+dict_has_attributes (const struct dictionary *d)
{
return attrset_count (&d->attributes) > 0;
}
-/* Called from variable.c to notify the dictionary that some property of
- the variable has changed */
+/* Called from variable.c to notify the dictionary that some property (indicated
+ by WHAT) of the variable has changed. OLDVAR is a copy of V as it existed
+ prior to the change. OLDVAR is destroyed by this function.
+*/
void
-dict_var_changed (const struct variable *v)
+dict_var_changed (const struct variable *v, unsigned int what, struct variable *oldvar)
{
- if ( var_has_vardict (v))
+ if (var_has_vardict (v))
{
const struct vardict_info *vardict = var_get_vardict (v);
struct dictionary *d = vardict->dict;
- if ( NULL == d)
+ if (NULL == d)
return;
- if (d->changed ) d->changed (d, d->changed_data);
- if ( d->callbacks && d->callbacks->var_changed )
- d->callbacks->var_changed (d, var_get_dict_index (v), d->cb_data);
- }
-}
-
-
-/* Called from variable.c to notify the dictionary that the variable's width
- has changed */
-void
-dict_var_resized (const struct variable *v, int old_width)
-{
- if ( var_has_vardict (v))
- {
- const struct vardict_info *vardict = var_get_vardict (v);
- struct dictionary *d;
-
- d = vardict->dict;
+ if (what & (VAR_TRAIT_WIDTH | VAR_TRAIT_POSITION))
+ invalidate_proto (d);
if (d->changed) d->changed (d, d->changed_data);
-
- invalidate_proto (d);
- if ( d->callbacks && d->callbacks->var_resized )
- d->callbacks->var_resized (d, var_get_dict_index (v), old_width,
- d->cb_data);
+ if (d->callbacks && d->callbacks->var_changed)
+ d->callbacks->var_changed (d, var_get_dict_index (v), what, oldvar, d->cb_data);
}
+ var_unref (oldvar);
}
-/* Called from variable.c to notify the dictionary that the variable's display width
- has changed */
-void
-dict_var_display_width_changed (const struct variable *v)
-{
- if ( var_has_vardict (v))
- {
- const struct vardict_info *vardict = var_get_vardict (v);
- struct dictionary *d;
- 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;
/* 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)
+ if (dict_get_n_vars (internal_dict) == 0)
{
- dict_destroy (internal_dict);
+ dict_unref (internal_dict);
internal_dict = NULL;
}
}
int
vardict_get_dict_index (const struct vardict_info *vardict)
{
- return vardict - vardict->dict->var;
+ return vardict - vardict->dict->vars;
}