/* 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
{
struct variable **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. */
int next_value_idx; /* Index of next `union value' to allocate. */
const struct variable **split; /* SPLIT FILE vars. */
dict_set_encoding (struct dictionary *d, const char *enc)
{
if (enc)
- d->encoding = xstrdup (enc);
+ {
+ free (d->encoding);
+ d->encoding = xstrdup (enc);
+ }
}
const char *
d->changed_data = data;
}
+/* Discards dictionary D's caseproto. (It will be regenerated
+ lazily, on demand.) */
+static void
+invalidate_proto (struct dictionary *d)
+{
+ caseproto_unref (d->proto);
+ d->proto = NULL;
+}
/* Print a representation of dictionary D to stdout, for
debugging purposes. */
{
const struct variable *v =
d->var[i];
- printf ("Name: %s;\tdict_idx: %d; case_idx: %d\n",
+ printf ("Name: %s;\tdict_idx: %zu; case_idx: %zu\n",
var_get_name (v),
var_get_dict_index (v),
var_get_case_index (v));
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 *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;
{
/* 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]);
free (d->var);
d->var = NULL;
d->var_cnt = d->var_cap = 0;
+ invalidate_proto (d);
hsh_clear (d->name_tab);
d->next_value_idx = 0;
dict_set_split_vars (d, NULL, 0);
{
int i;
- assert (d != NULL);
-
for (i = 0; i < d->var_cnt; i++)
var_clear_aux (d->var[i]);
}
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];
size_t count;
size_t i;
- assert (d != NULL);
- assert (vars != NULL);
- assert (cnt != NULL);
assert (exclude == (exclude & DC_ALL));
count = 0;
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)
if ( d->callbacks && d->callbacks->var_added )
d->callbacks->var_added (d, var_get_dict_index (v), d->cb_data);
- d->next_value_idx += var_get_value_cnt (v);
+ d->next_value_idx++;
+ invalidate_proto (d);
return v;
}
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.
{
int dict_index = var_get_dict_index (v);
const int case_index = var_get_case_index (v);
- const int val_cnt = var_get_value_cnt (v);
+ const int width = var_get_width (v);
assert (dict_contains_var (d, v));
/* Free memory. */
+ free (var_get_vardict (v));
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, val_cnt, d->cb_data);
+ d->callbacks->var_deleted (d, dict_index, case_index, width, d->cb_data);
}
/* Deletes the COUNT variables listed in VARS from D. This is
{
/* 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)
/* 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]);
struct variable **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);
+ 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
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;
}
+/* Returns the prototype used for cases created by dictionary D. */
+const struct caseproto *
+dict_get_proto (const struct dictionary *d_)
+{
+ struct dictionary *d = CONST_CAST (struct dictionary *, d_);
+ if (d->proto == NULL)
+ {
+ 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_set_width (d->proto,
+ var_get_case_index (d->var[i]),
+ var_get_width (d->var[i]));
+ }
+ return d->proto;
+}
+
/* Returns the case index of the next value to be added to D.
This value is the number of `union value's that need to be
allocated to store a case for dictionary D. */
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);
}
for (i = 0; i < d->var_cnt; i++)
{
struct variable *v = d->var[i];
- set_var_case_index (v, d->next_value_idx);
- d->next_value_idx += var_get_value_cnt (v);
+ set_var_case_index (v, d->next_value_idx++);
}
+ invalidate_proto (d);
}
-/*
- Reassigns case indices for D, increasing each index above START by
- the value PADDING.
-*/
-static void
-dict_pad_values (struct dictionary *d, int start, int padding)
-{
- size_t i;
-
- if ( padding <= 0 )
- return;
-
- for (i = 0; i < d->var_cnt; ++i)
- {
- struct variable *v = d->var[i];
-
- int index = var_get_case_index (v);
-
- if ( index >= start)
- set_var_case_index (v, index + padding);
- }
-
- d->next_value_idx += padding;
-}
-
-
/* Returns the number of values occupied by the variables in
dictionary D. All variables are considered if EXCLUDE_CLASSES
is 0, or it may contain one or more of (1u << DC_ORDINARY),
{
enum dict_class class = var_get_dict_class (d->var[i]);
if (!(exclude_classes & (1u << class)))
- cnt += var_get_value_cnt (d->var[i]);
+ cnt++;
}
return cnt;
}
+
+/* Returns the case prototype that would result after deleting
+ all variables from D that are not in one of the
+ EXCLUDE_CLASSES and compacting the dictionary with
+ dict_compact().
+
+ The caller must unref the returned caseproto when it is no
+ longer needed. */
+struct caseproto *
+dict_get_compacted_proto (const struct dictionary *d,
+ unsigned int exclude_classes)
+{
+ struct caseproto *proto;
+ size_t i;
+
+ assert ((exclude_classes & ~((1u << DC_ORDINARY)
+ | (1u << DC_SYSTEM)
+ | (1u << DC_SCRATCH))) == 0);
+
+ proto = caseproto_create ();
+ for (i = 0; i < d->var_cnt; i++)
+ {
+ struct variable *v = d->var[i];
+ 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
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;
}
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;
}
msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
}
buf_copy_str_rpad (ds_put_uninit (&d->documents, DOC_LINE_LENGTH),
- DOC_LINE_LENGTH, line);
+ DOC_LINE_LENGTH, line, ' ');
}
/* Returns the number of document lines in dictionary D. */
{
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;
}
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. */
/* Called from variable.c to notify the dictionary that the variable's width
has changed */
void
-dict_var_resized (const struct variable *v, int delta)
+dict_var_resized (const struct variable *v, int old_width)
{
if ( var_has_vardict (v))
{
d = vdi->dict;
- dict_pad_values (d, var_get_case_index(v) + 1, delta);
-
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), delta, d->cb_data);
+ d->callbacks->var_resized (d, var_get_dict_index (v), old_width,
+ d->cb_data);
}
}
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