/* 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
dict_set_encoding (struct dictionary *d, const char *enc)
{
if (enc)
- d->encoding = xstrdup (enc);
+ {
+ free (d->encoding);
+ d->encoding = xstrdup (enc);
+ }
}
const char *
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 *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;
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 *vdi;
+
+ vdi = xmalloc (sizeof *vdi);
+ vdi->case_index = d->next_value_idx;
+ vdi->dict_index = d->var_cnt;
+ vdi->dict = d;
+ var_set_vardict (v, vdi);
/* Update dictionary. */
if (d->var_cnt >= d->var_cap)
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);
/* Sets the dict_index in V's vardict to DICT_INDEX. */
static void
-set_var_dict_index (struct variable *v, int dict_index)
+set_var_dict_index (struct dictionary *d, struct variable *v, int dict_index)
{
- struct vardict_info vdi = *var_get_vardict (v);
- struct dictionary *d = vdi.dict;
- vdi.dict_index = dict_index;
- var_set_vardict (v, &vdi);
+ var_get_vardict (v)->dict_index = dict_index;
if ( d->changed ) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->var_changed )
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;
}
/* 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);
+ set_var_dict_index (d, d->var[i], i);
}
/* Deletes variable V from dictionary D and frees V.
/* Free memory. */
+ free (var_get_vardict (v));
var_clear_vardict (v);
var_destroy (v);
assert (count == 0 || order != NULL);
assert (count <= d->var_cnt);
- new_var = xnmalloc (d->var_cnt, sizeof *new_var);
+ new_var = xnmalloc (d->var_cap, sizeof *new_var);
memcpy (new_var, order, count * sizeof *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);
+ set_var_dict_index (d, order[i], i);
}
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);
+ set_var_dict_index (d, new_var[count], count);
count++;
}
free (d->var);
static void
rename_var (struct dictionary *d, struct variable *v, const char *new_name)
{
- struct vardict_info vdi;
+ struct vardict_info *vardict;
assert (dict_contains_var (d, v));
- vdi = *var_get_vardict (v);
+ vardict = var_get_vardict (v);
var_clear_vardict (v);
var_set_name (v, new_name);
- var_set_vardict (v, &vdi);
+ var_set_vardict (v, vardict);
}
/* Changes the name of V in D to name NEW_NAME. Assert-fails if
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;
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. */
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;
+ }
+ }
+}
projects / pspp / blobdiff