X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=2dd1dfc4641108a08deb9b3e054acb7e872e53da;hb=9e0e4996fad6563f0a1ce628b80db5c23ef8279e;hp=d77d9fdd1ed2b78620a87a6103f6f4304f0c4095;hpb=8021cf8974a46fe82af7b8952e448c0ea6858a48;p=pspp-builds.git
diff --git a/src/data/dictionary.c b/src/data/dictionary.c
index d77d9fdd..2dd1dfc4 100644
--- a/src/data/dictionary.c
+++ b/src/data/dictionary.c
@@ -1,20 +1,18 @@
-/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000, 2006, 2007 Free Software Foundation, Inc.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 1997-9, 2000, 2006, 2007, 2009 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 the Free Software Foundation; either version 2 of the
- License, or (at your option) any later version.
+ 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see . */
#include
@@ -23,15 +21,17 @@
#include
#include
-#include "case.h"
-#include "category.h"
-#include "settings.h"
-#include "value-labels.h"
-#include "vardict.h"
-#include "variable.h"
-#include "vector.h"
-#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
#include
+#include
#include
#include
#include
@@ -39,7 +39,9 @@
#include
#include
+#include "intprops.h"
#include "minmax.h"
+#include "xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
@@ -55,17 +57,66 @@ struct dictionary
size_t split_cnt; /* SPLIT FILE count. */
struct variable *weight; /* WEIGHT variable. */
struct variable *filter; /* FILTER variable. */
- size_t case_limit; /* Current case limit (N command). */
+ casenumber case_limit; /* Current case limit (N command). */
char *label; /* File label. */
struct string documents; /* Documents, as a string. */
struct vector **vector; /* Vectors of variables. */
size_t vector_cnt; /* Number of vectors. */
+ struct attrset attributes; /* Custom attributes. */
+
+ char *encoding; /* Character encoding of string data */
+
const struct dict_callbacks *callbacks; /* Callbacks on dictionary
modification */
void *cb_data ; /* Data passed to callbacks */
+
+ void (*changed) (struct dictionary *, void *); /* Generic change callback */
+ void *changed_data;
};
+void
+dict_set_encoding (struct dictionary *d, const char *enc)
+{
+ if (enc)
+ d->encoding = xstrdup (enc);
+}
+
+const char *
+dict_get_encoding (const struct dictionary *d)
+{
+ return d->encoding ;
+}
+
+
+void
+dict_set_change_callback (struct dictionary *d,
+ void (*changed) (struct dictionary *, void*),
+ void *data)
+{
+ d->changed = changed;
+ d->changed_data = data;
+}
+
+
+/* Print a representation of dictionary D to stdout, for
+ debugging purposes. */
+void
+dict_dump (const struct dictionary *d)
+{
+ int i;
+ for (i = 0 ; i < d->var_cnt ; ++i )
+ {
+ const struct variable *v =
+ d->var[i];
+ printf ("Name: %s;\tdict_idx: %d; case_idx: %d\n",
+ var_get_name (v),
+ var_get_dict_index (v),
+ var_get_case_index (v));
+
+ }
+}
+
/* Associate CALLBACKS with DICT. Callbacks will be invoked whenever
the dictionary or any of the variables it contains are modified.
Each callback will get passed CALLBACK_DATA.
@@ -97,11 +148,18 @@ dict_create (void)
d->name_tab = hsh_create (8, compare_vars_by_name, hash_var_by_name,
NULL, NULL);
+ attrset_init (&d->attributes);
return d;
}
/* Creates and returns a (deep) copy of an existing
- dictionary. */
+ dictionary.
+
+ The new dictionary's case indexes are copied from the old
+ 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. */
struct dictionary *
dict_clone (const struct dictionary *s)
{
@@ -114,9 +172,19 @@ dict_clone (const struct dictionary *s)
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));
- var_set_short_name (dv, var_get_short_name (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);
}
d->next_value_idx = s->next_value_idx;
@@ -144,6 +212,11 @@ dict_clone (const struct dictionary *s)
for (i = 0; i < s->vector_cnt; i++)
d->vector[i] = vector_clone (s->vector[i], s, d);
+ if ( s->encoding)
+ d->encoding = xstrdup (s->encoding);
+
+ dict_set_attributes (d, dict_get_attributes (s));
+
return d;
}
@@ -158,14 +231,9 @@ dict_clear (struct dictionary *d)
while (d->var_cnt > 0 )
{
- var_clear_vardict (d->var[d->var_cnt - 1]);
- var_destroy (d->var[d->var_cnt -1]);
-
- d->var_cnt--;
-
- if (d->callbacks && d->callbacks->var_deleted )
- d->callbacks->var_deleted (d, d->var_cnt, d->cb_data);
+ dict_delete_var (d, d->var[d->var_cnt - 1]);
}
+
free (d->var);
d->var = NULL;
d->var_cnt = d->var_cap = 0;
@@ -179,6 +247,7 @@ dict_clear (struct dictionary *d)
d->label = NULL;
ds_destroy (&d->documents);
dict_clear_vectors (d);
+ attrset_clear (&d->attributes);
}
/* Destroys the aux data for every variable in D, by calling
@@ -206,6 +275,7 @@ dict_destroy (struct dictionary *d)
dict_clear (d);
hsh_destroy (d->name_tab);
+ attrset_destroy (&d->attributes);
free (d);
}
}
@@ -231,21 +301,26 @@ dict_get_var (const struct dictionary *d, size_t idx)
return d->var[idx];
}
-inline void
+/* Sets *VARS to an array of pointers to variables in D and *CNT
+ 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, unsigned exclude_classes)
+ size_t *cnt, enum dict_class exclude)
{
- dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude_classes);
+ dict_get_vars_mutable (d, (struct variable ***) vars, cnt, exclude);
}
/* Sets *VARS to an array of pointers to variables in D and *CNT
to the number of variables in *D. All variables are returned
- if EXCLUDE_CLASSES is 0, or it may contain one or more of (1u
- << DC_ORDINARY), (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to
- exclude the corresponding type of variable. */
+ 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, unsigned exclude_classes)
+ size_t *cnt, enum dict_class exclude)
{
size_t count;
size_t i;
@@ -253,15 +328,13 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
assert (d != NULL);
assert (vars != NULL);
assert (cnt != NULL);
- assert ((exclude_classes & ~((1u << DC_ORDINARY)
- | (1u << DC_SYSTEM)
- | (1u << DC_SCRATCH))) == 0);
+ assert (exclude == (exclude & DC_ALL));
count = 0;
for (i = 0; i < d->var_cnt; i++)
{
- enum dict_class class = dict_class_from_id (var_get_name (d->var[i]));
- if (!(exclude_classes & (1u << class)))
+ enum dict_class class = var_get_dict_class (d->var[i]);
+ if (!(class & exclude))
count++;
}
@@ -269,8 +342,8 @@ dict_get_vars_mutable (const struct dictionary *d, struct variable ***vars,
*cnt = 0;
for (i = 0; i < d->var_cnt; i++)
{
- enum dict_class class = dict_class_from_id (var_get_name (d->var[i]));
- if (!(exclude_classes & (1u << class)))
+ enum dict_class class = var_get_dict_class (d->var[i]);
+ if (!(class & exclude))
(*vars)[(*cnt)++] = d->var[i];
}
assert (*cnt == count);
@@ -295,6 +368,7 @@ add_var (struct dictionary *d, struct variable *v)
d->var[d->var_cnt++] = v;
hsh_force_insert (d->name_tab, v);
+ 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);
@@ -360,13 +434,19 @@ dict_lookup_var (const struct dictionary *d, const char *name)
struct variable *target ;
struct variable *result ;
- if ( ! var_is_valid_name (name, false))
+ if ( ! var_is_plausible_name (name, false))
return NULL;
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);
+ }
+
return result;
}
@@ -416,11 +496,12 @@ set_var_dict_index (struct variable *v, int dict_index)
vdi.dict_index = dict_index;
var_set_vardict (v, &vdi);
+ 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);
}
-/* Sets the case_index in V's vardict to DICT_INDEX. */
+/* Sets the case_index in V's vardict to CASE_INDEX. */
static void
set_var_case_index (struct variable *v, int case_index)
{
@@ -448,7 +529,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to)
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 MODIFY VARS.
+ 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,
@@ -457,6 +538,8 @@ 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 val_cnt = var_get_value_cnt (v);
assert (dict_contains_var (d, v));
@@ -488,8 +571,9 @@ dict_delete_var (struct dictionary *d, struct variable *v)
var_clear_vardict (v);
var_destroy (v);
+ if ( d->changed ) d->changed (d, d->changed_data);
if (d->callbacks && d->callbacks->var_deleted )
- d->callbacks->var_deleted (d, dict_index, d->cb_data);
+ d->callbacks->var_deleted (d, dict_index, case_index, val_cnt, d->cb_data);
}
/* Deletes the COUNT variables listed in VARS from D. This is
@@ -532,7 +616,7 @@ dict_delete_scratch_vars (struct dictionary *d)
assert (d != NULL);
for (i = 0; i < d->var_cnt; )
- if (dict_class_from_id (var_get_name (d->var[i])) == DC_SCRATCH)
+ if (var_get_dict_class (d->var[i]) == DC_SCRATCH)
dict_delete_var (d, d->var[i]);
else
i++;
@@ -615,9 +699,10 @@ dict_rename_var (struct dictionary *d, struct variable *v,
rename_var (d, v, new_name);
hsh_force_insert (d->name_tab, v);
- if (get_algorithm () == ENHANCED)
- var_clear_short_name (v);
+ 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);
}
@@ -680,14 +765,131 @@ dict_rename_vars (struct dictionary *d,
}
/* Clear short names. */
- if (get_algorithm () == ENHANCED)
+ if (settings_get_algorithm () == ENHANCED)
for (i = 0; i < count; i++)
- var_clear_short_name (vars[i]);
+ var_clear_short_names (vars[i]);
pool_destroy (pool);
return true;
}
+/* Returns true if a variable named NAME may be inserted in DICT;
+ that is, if there is not already a variable with that name in
+ DICT and if NAME is not a reserved word. (The caller's checks
+ have already verified that NAME is otherwise acceptable as a
+ variable name.) */
+static bool
+var_name_is_insertable (const struct dictionary *dict, const char *name)
+{
+ return (dict_lookup_var (dict, name) == NULL
+ && lex_id_to_token (ss_cstr (name)) == T_ID);
+}
+
+static bool
+make_hinted_name (const struct dictionary *dict, const char *hint,
+ char name[VAR_NAME_LEN + 1])
+{
+ bool dropped = false;
+ char *cp;
+
+ for (cp = name; *hint && cp < name + VAR_NAME_LEN; hint++)
+ {
+ if (cp == name
+ ? lex_is_id1 (*hint) && *hint != '$'
+ : lex_is_idn (*hint))
+ {
+ if (dropped)
+ {
+ *cp++ = '_';
+ dropped = false;
+ }
+ if (cp < name + VAR_NAME_LEN)
+ *cp++ = *hint;
+ }
+ else if (cp > name)
+ dropped = true;
+ }
+ *cp = '\0';
+
+ if (name[0] != '\0')
+ {
+ size_t len = strlen (name);
+ unsigned long int i;
+
+ if (var_name_is_insertable (dict, name))
+ return true;
+
+ for (i = 0; i < ULONG_MAX; i++)
+ {
+ char suffix[INT_BUFSIZE_BOUND (i) + 1];
+ int ofs;
+
+ suffix[0] = '_';
+ if (!str_format_26adic (i + 1, &suffix[1], sizeof suffix - 1))
+ NOT_REACHED ();
+
+ ofs = MIN (VAR_NAME_LEN - strlen (suffix), len);
+ strcpy (&name[ofs], suffix);
+
+ if (var_name_is_insertable (dict, name))
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static bool
+make_numeric_name (const struct dictionary *dict, unsigned long int *num_start,
+ char name[VAR_NAME_LEN + 1])
+{
+ unsigned long int number;
+
+ for (number = num_start != NULL ? MAX (*num_start, 1) : 1;
+ number < ULONG_MAX;
+ number++)
+ {
+ sprintf (name, "VAR%03lu", number);
+ if (dict_lookup_var (dict, name) == NULL)
+ {
+ if (num_start != NULL)
+ *num_start = number + 1;
+ return true;
+ }
+ }
+
+ if (num_start != NULL)
+ *num_start = ULONG_MAX;
+ return false;
+}
+
+
+/* Attempts to devise a variable name unique within DICT.
+ Returns true if successful, in which case the new variable
+ name is stored into NAME. Returns false if all names that can
+ be generated have already been taken. (Returning false is
+ quite unlikely: at least ULONG_MAX unique names can be
+ generated.)
+
+ HINT, if it is non-null, is used as a suggestion that will be
+ modified for suitability as a variable name and for
+ uniqueness.
+
+ If HINT is null or entirely unsuitable, a name in the form
+ "VAR%03d" will be generated, where the smallest unused integer
+ value is used. If NUM_START is non-null, then its value is
+ used as the minimum numeric value to check, and it is updated
+ to the next value to be checked.
+ */
+bool
+dict_make_unique_var_name (const struct dictionary *dict, const char *hint,
+ unsigned long int *num_start,
+ char name[VAR_NAME_LEN + 1])
+{
+ return ((hint != NULL && make_hinted_name (dict, hint, name))
+ || make_numeric_name (dict, num_start, name));
+}
+
/* Returns the weighting variable in dictionary D, or a null
pointer if the dictionary is unweighted. */
struct variable *
@@ -699,11 +901,12 @@ dict_get_weight (const struct dictionary *d)
return d->weight;
}
-/* Returns the value of D's weighting variable in case C, except that a
- negative weight is returned as 0. Returns 1 if the dictionary is
- unweighted. Will warn about missing, negative, or zero values if
- warn_on_invalid is true. The function will set warn_on_invalid to false
- if an invalid weight is found. */
+/* Returns the value of D's weighting variable in case C, except
+ that a negative weight is returned as 0. Returns 1 if the
+ dictionary is unweighted. Will warn about missing, negative,
+ or zero values if *WARN_ON_INVALID is true. The function will
+ set *WARN_ON_INVALID to false if an invalid weight is
+ found. */
double
dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
bool *warn_on_invalid)
@@ -718,7 +921,7 @@ dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
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 ) {
+ 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 "
@@ -739,6 +942,7 @@ dict_set_weight (struct dictionary *d, struct variable *v)
d->weight = v;
+ if (d->changed) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->weight_changed )
d->callbacks->weight_changed (d,
v ? var_get_dict_index (v) : -1,
@@ -763,9 +967,11 @@ 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));
d->filter = v;
+ if (d->changed) d->changed (d, d->changed_data);
if ( d->callbacks && d->callbacks->filter_changed )
d->callbacks->filter_changed (d,
v ? var_get_dict_index (v) : -1,
@@ -774,7 +980,7 @@ dict_set_filter (struct dictionary *d, struct variable *v)
/* Returns the case limit for dictionary D, or zero if the number
of cases is unlimited. */
-size_t
+casenumber
dict_get_case_limit (const struct dictionary *d)
{
assert (d != NULL);
@@ -785,7 +991,7 @@ dict_get_case_limit (const struct dictionary *d)
/* Sets CASE_LIMIT as the case limit for dictionary D. Use
0 for CASE_LIMIT to indicate no limit. */
void
-dict_set_case_limit (struct dictionary *d, size_t case_limit)
+dict_set_case_limit (struct dictionary *d, casenumber case_limit)
{
assert (d != NULL);
@@ -813,204 +1019,78 @@ dict_get_case_size (const struct dictionary *d)
return sizeof (union value) * dict_get_next_value_idx (d);
}
-/* Deletes scratch variables in dictionary D and reassigns values
- so that fragmentation is eliminated. */
+/* Reassigns values in dictionary D so that fragmentation is
+ eliminated. */
void
dict_compact_values (struct dictionary *d)
{
size_t i;
d->next_value_idx = 0;
- for (i = 0; i < d->var_cnt; )
+ for (i = 0; i < d->var_cnt; i++)
{
struct variable *v = d->var[i];
-
- if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH)
- {
- set_var_case_index (v, d->next_value_idx);
- d->next_value_idx += var_get_value_cnt (v);
- i++;
- }
- else
- dict_delete_var (d, v);
+ set_var_case_index (v, d->next_value_idx);
+ d->next_value_idx += var_get_value_cnt (v);
}
}
-/* Returns the number of values that would be used by a case if
- dict_compact_values() were called. */
-size_t
-dict_get_compacted_value_cnt (const struct dictionary *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;
- size_t cnt;
- cnt = 0;
- for (i = 0; i < d->var_cnt; i++)
- if (dict_class_from_id (var_get_name (d->var[i])) != DC_SCRATCH)
- cnt += var_get_value_cnt (d->var[i]);
- return cnt;
-}
-
-/* Creates and returns an array mapping from a dictionary index
- to the case index that the corresponding variable will have
- after calling dict_compact_values(). Scratch variables
- receive -1 for case index because dict_compact_values() will
- delete them. */
-int *
-dict_get_compacted_dict_index_to_case_index (const struct dictionary *d)
-{
- size_t i;
- size_t next_value_idx;
- int *map;
+ if ( padding <= 0 )
+ return;
- map = xnmalloc (d->var_cnt, sizeof *map);
- next_value_idx = 0;
- for (i = 0; i < d->var_cnt; i++)
+ for (i = 0; i < d->var_cnt; ++i)
{
struct variable *v = d->var[i];
- if (dict_class_from_id (var_get_name (v)) != DC_SCRATCH)
- {
- map[i] = next_value_idx;
- next_value_idx += var_get_value_cnt (v);
- }
- else
- map[i] = -1;
- }
- return map;
-}
-
-/* Returns true if a case for dictionary D would be smaller after
- compacting, false otherwise. Compacting a case eliminates
- "holes" between values and after the last value. Holes are
- created by deleting variables (or by scratch variables).
+ int index = var_get_case_index (v);
- The return value may differ from whether compacting a case
- from dictionary D would *change* the case: compacting could
- rearrange values even if it didn't reduce space
- requirements. */
-bool
-dict_compacting_would_shrink (const struct dictionary *d)
-{
- return dict_get_compacted_value_cnt (d) < dict_get_next_value_idx (d);
-}
-
-/* Returns true if a case for dictionary D would change after
- compacting, false otherwise. Compacting a case eliminates
- "holes" between values and after the last value. Holes are
- created by deleting variables (or by scratch variables).
-
- The return value may differ from whether compacting a case
- from dictionary D would *shrink* the case: compacting could
- rearrange values without reducing space requirements. */
-bool
-dict_compacting_would_change (const struct dictionary *d)
-{
- size_t case_idx;
- size_t i;
-
- case_idx = 0;
- for (i = 0; i < dict_get_var_cnt (d); i++)
- {
- struct variable *v = dict_get_var (d, i);
- if (var_get_case_index (v) != case_idx)
- return true;
- case_idx += var_get_value_cnt (v);
+ if ( index >= start)
+ set_var_case_index (v, index + padding);
}
- return false;
+
+ d->next_value_idx += padding;
}
-
-/* How to copy a contiguous range of values between cases. */
-struct copy_map
- {
- size_t src_idx; /* Starting value index in source case. */
- size_t dst_idx; /* Starting value index in target case. */
- size_t cnt; /* Number of values. */
- };
-/* How to compact a case. */
-struct dict_compactor
- {
- struct copy_map *maps; /* Array of mappings. */
- size_t map_cnt; /* Number of mappings. */
- };
-/* Creates and returns a dict_compactor that can be used to
- compact cases for dictionary D.
+/* 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),
+ (1u << DC_SYSTEM), or (1u << DC_SCRATCH) to exclude the
+ corresponding type of variable.
- Compacting a case eliminates "holes" between values and after
- the last value. Holes are created by deleting variables (or
- by scratch variables). */
-struct dict_compactor *
-dict_make_compactor (const struct dictionary *d)
+ The return value may be less than the number of values in one
+ of dictionary D's cases (as returned by
+ dict_get_next_value_idx) even if E is 0, because there may be
+ gaps in D's cases due to deleted variables. */
+size_t
+dict_count_values (const struct dictionary *d, unsigned int exclude_classes)
{
- struct dict_compactor *compactor;
- struct copy_map *map;
- size_t map_allocated;
- size_t value_idx;
size_t i;
+ size_t cnt;
- compactor = xmalloc (sizeof *compactor);
- compactor->maps = NULL;
- compactor->map_cnt = 0;
- map_allocated = 0;
+ assert ((exclude_classes & ~((1u << DC_ORDINARY)
+ | (1u << DC_SYSTEM)
+ | (1u << DC_SCRATCH))) == 0);
- value_idx = 0;
- map = NULL;
+ cnt = 0;
for (i = 0; i < d->var_cnt; i++)
{
- struct variable *v = d->var[i];
-
- if (dict_class_from_id (var_get_name (v)) == DC_SCRATCH)
- continue;
- if (map != NULL && map->src_idx + map->cnt == var_get_case_index (v))
- map->cnt += var_get_value_cnt (v);
- else
- {
- if (compactor->map_cnt == map_allocated)
- compactor->maps = x2nrealloc (compactor->maps, &map_allocated,
- sizeof *compactor->maps);
- map = &compactor->maps[compactor->map_cnt++];
- map->src_idx = var_get_case_index (v);
- map->dst_idx = value_idx;
- map->cnt = var_get_value_cnt (v);
- }
- value_idx += var_get_value_cnt (v);
- }
-
- return compactor;
-}
-
-/* Compacts SRC by copying it to DST according to the scheme in
- COMPACTOR.
-
- Compacting a case eliminates "holes" between values and after
- the last value. Holes are created by deleting variables (or
- by scratch variables). */
-void
-dict_compactor_compact (const struct dict_compactor *compactor,
- struct ccase *dst, const struct ccase *src)
-{
- size_t i;
-
- for (i = 0; i < compactor->map_cnt; i++)
- {
- const struct copy_map *map = &compactor->maps[i];
- case_copy (dst, map->dst_idx, src, map->src_idx, map->cnt);
- }
-}
-
-/* Destroys COMPACTOR. */
-void
-dict_compactor_destroy (struct dict_compactor *compactor)
-{
- if (compactor != NULL)
- {
- free (compactor->maps);
- free (compactor);
+ enum dict_class class = var_get_dict_class (d->var[i]);
+ if (!(exclude_classes & (1u << class)))
+ cnt += var_get_value_cnt (d->var[i]);
}
+ return cnt;
}
-
+
/* 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
@@ -1032,20 +1112,26 @@ dict_get_split_cnt (const struct dictionary *d)
return d->split_cnt;
}
-/* Removes variable V from the set of split variables in dictionary D */
+/* Removes variable V, which must be in D, from D's set of split
+ variables. */
void
-dict_unset_split_var (struct dictionary *d,
- struct variable *v)
+dict_unset_split_var (struct dictionary *d, struct variable *v)
{
- const int count = d->split_cnt;
- d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
- &v, compare_var_ptrs, NULL);
+ int orig_count;
- if ( count == d->split_cnt)
- return;
+ assert (dict_contains_var (d, v));
- if ( d->callbacks && d->callbacks->split_changed )
- d->callbacks->split_changed (d, d->cb_data);
+ 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. */
@@ -1057,9 +1143,18 @@ dict_set_split_vars (struct dictionary *d,
assert (cnt == 0 || split != NULL);
d->split_cnt = cnt;
- d->split = cnt > 0 ? xnrealloc (d->split, cnt, sizeof *d->split) : NULL;
- memcpy (d->split, split, cnt * sizeof *d->split);
+ 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);
}
@@ -1082,16 +1177,7 @@ dict_set_label (struct dictionary *d, const char *label)
assert (d != NULL);
free (d->label);
- if (label == NULL)
- d->label = NULL;
- else if (strlen (label) < 60)
- d->label = xstrdup (label);
- else
- {
- d->label = xmalloc (61);
- memcpy (d->label, label, 60);
- d->label[60] = '\0';
- }
+ d->label = label != NULL ? xstrndup (label, 60) : NULL;
}
/* Returns the documents for D, or a null pointer if D has no
@@ -1113,7 +1199,7 @@ void
dict_set_documents (struct dictionary *d, const char *documents)
{
size_t remainder;
-
+
ds_assign_cstr (&d->documents, documents != NULL ? documents : "");
/* In case the caller didn't get it quite right, pad out the
@@ -1125,7 +1211,7 @@ dict_set_documents (struct dictionary *d, const char *documents)
/* Drops the documents from dictionary D. */
void
-dict_clear_documents (struct dictionary *d)
+dict_clear_documents (struct dictionary *d)
{
ds_clear (&d->documents);
}
@@ -1136,10 +1222,10 @@ dict_clear_documents (struct dictionary *d)
void
dict_add_document_line (struct dictionary *d, const char *line)
{
- if (strlen (line) > DOC_LINE_LENGTH)
+ if (strlen (line) > DOC_LINE_LENGTH)
{
/* Note to translators: "bytes" is correct, not characters */
- msg (SW, _("Truncating document line to %d bytes."), DOC_LINE_LENGTH);
+ 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);
@@ -1147,7 +1233,7 @@ dict_add_document_line (struct dictionary *d, const char *line)
/* Returns the number of document lines in dictionary D. */
size_t
-dict_get_document_line_cnt (const struct dictionary *d)
+dict_get_document_line_cnt (const struct dictionary *d)
{
return ds_length (&d->documents) / DOC_LINE_LENGTH;
}
@@ -1156,7 +1242,7 @@ dict_get_document_line_cnt (const struct dictionary *d)
LINE, trimming off any trailing white space. */
void
dict_get_document_line (const struct dictionary *d,
- size_t idx, struct string *line)
+ size_t idx, struct string *line)
{
assert (idx < dict_get_document_line_cnt (d));
ds_assign_substring (line, ds_substr (&d->documents, idx * DOC_LINE_LENGTH,
@@ -1247,137 +1333,76 @@ dict_clear_vectors (struct dictionary *d)
d->vector_cnt = 0;
}
-/* Compares two strings. */
-static int
-compare_strings (const void *a, const void *b, const void *aux UNUSED)
+/* 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
+ attribute set. */
+struct attrset *
+dict_get_attributes (const struct dictionary *d)
{
- return strcmp (a, b);
+ return (struct attrset *) &d->attributes;
}
-/* Hashes a string. */
-static unsigned
-hash_string (const void *s, const void *aux UNUSED)
+/* Replaces D's attributes set by a copy of ATTRS. */
+void
+dict_set_attributes (struct dictionary *d, const struct attrset *attrs)
{
- return hsh_hash_string (s);
+ attrset_destroy (&d->attributes);
+ attrset_clone (&d->attributes, attrs);
}
-
-/* Sets V's short name to BASE, followed by a suffix of the form
- _A, _B, _C, ..., _AA, _AB, etc. according to the value of
- SUFFIX_NUMBER. Truncates BASE as necessary to fit. */
-static void
-set_var_short_name_suffix (struct variable *v, const char *base,
- int suffix_number)
+/* 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)
{
- char suffix[SHORT_NAME_LEN + 1];
- char short_name[SHORT_NAME_LEN + 1];
- char *start, *end;
- int len, ofs;
+ return attrset_count (&d->attributes) > 0;
+}
- assert (v != NULL);
- assert (suffix_number >= 0);
+/* Called from variable.c to notify the dictionary that some property of
+ the variable has changed */
+void
+dict_var_changed (const struct variable *v)
+{
+ if ( var_has_vardict (v))
+ {
+ const struct vardict_info *vdi = var_get_vardict (v);
+ struct dictionary *d = vdi->dict;
- /* Set base name. */
- var_set_short_name (v, base);
+ if ( NULL == d)
+ return;
- /* Compose suffix. */
- start = end = suffix + sizeof suffix - 1;
- *end = '\0';
- do
- {
- *--start = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[suffix_number % 26];
- if (start <= suffix + 1)
- msg (SE, _("Variable suffix too large."));
- suffix_number /= 26;
+ 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);
}
- while (suffix_number > 0);
- *--start = '_';
-
- /* Append suffix to V's short name. */
- str_copy_trunc (short_name, sizeof short_name, base);
- len = end - start;
- if (len + strlen (short_name) > SHORT_NAME_LEN)
- ofs = SHORT_NAME_LEN - len;
- else
- ofs = strlen (short_name);
- strcpy (short_name + ofs, start);
-
- /* Set name. */
- var_set_short_name (v, short_name);
}
-/* Assigns a valid, unique short_name[] to each variable in D.
- Each variable whose actual name is short has highest priority
- for that short name. Otherwise, variables with an existing
- short_name[] have the next highest priority for a given short
- name; if it is already taken, then the variable is treated as
- if short_name[] had been empty. Otherwise, long names are
- truncated to form short names. If that causes conflicts,
- variables are renamed as PREFIX_A, PREFIX_B, and so on. */
+
+/* Called from variable.c to notify the dictionary that the variable's width
+ has changed */
void
-dict_assign_short_names (struct dictionary *d)
+dict_var_resized (const struct variable *v, int delta)
{
- struct hsh_table *short_names;
- size_t i;
-
- /* Give variables whose names are short the corresponding short
- names, and clear short_names[] that conflict with a variable
- name. */
- for (i = 0; i < d->var_cnt; i++)
+ if ( var_has_vardict (v))
{
- struct variable *v = d->var[i];
- const char *short_name = var_get_short_name (v);
- if (strlen (var_get_name (v)) <= SHORT_NAME_LEN)
- var_set_short_name (v, var_get_name (v));
- else if (short_name != NULL && dict_lookup_var (d, short_name) != NULL)
- var_clear_short_name (v);
- }
+ const struct vardict_info *vdi = var_get_vardict (v);
+ struct dictionary *d;
- /* Each variable with an assigned short_name[] now gets it
- unless there is a conflict. */
- short_names = hsh_create (d->var_cnt, compare_strings, hash_string,
- NULL, NULL);
- for (i = 0; i < d->var_cnt; i++)
- {
- struct variable *v = d->var[i];
- const char *name = var_get_short_name (v);
- if (name != NULL && hsh_insert (short_names, (char *) name) != NULL)
- var_clear_short_name (v);
- }
+ d = vdi->dict;
- /* Now assign short names to remaining variables. */
- for (i = 0; i < d->var_cnt; i++)
- {
- struct variable *v = d->var[i];
- const char *name = var_get_short_name (v);
- if (name == NULL)
- {
- /* Form initial short_name from the variable name, then
- try _A, _B, ... _AA, _AB, etc., if needed.*/
- int trial = 0;
- do
- {
- if (trial == 0)
- var_set_short_name (v, var_get_name (v));
- else
- set_var_short_name_suffix (v, var_get_name (v), trial - 1);
+ dict_pad_values (d, var_get_case_index(v) + 1, delta);
- trial++;
- }
- while (hsh_insert (short_names, (char *) var_get_short_name (v))
- != NULL);
- }
+ if (d->changed) d->changed (d, d->changed_data);
+ if ( d->callbacks && d->callbacks->var_resized )
+ d->callbacks->var_resized (d, var_get_dict_index (v), delta, d->cb_data);
}
-
- /* Get rid of hash table. */
- hsh_destroy (short_names);
}
-
-/* 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 the variable's display width
+ has changed */
void
-dict_var_changed (const struct variable *v)
+dict_var_display_width_changed (const struct variable *v)
{
if ( var_has_vardict (v))
{
@@ -1386,7 +1411,9 @@ dict_var_changed (const struct variable *v)
d = vdi->dict;
- 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_display_width_changed )
+ d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data);
}
}
+