02111-1307, USA. */
#include <config.h>
-#include <assert.h>
+#include "dictionary.h"
#include <stdlib.h>
+#include <ctype.h>
#include "algorithm.h"
#include "alloc.h"
+#include "case.h"
+#include "error.h"
#include "hash.h"
#include "misc.h"
#include "str.h"
struct variable **var; /* Variables. */
size_t var_cnt, var_cap; /* Number of variables, capacity. */
struct hsh_table *name_tab; /* Variable index by name. */
+ struct hsh_table *long_name_tab; /* Variable indexed by long name */
int next_value_idx; /* Index of next `union value' to allocate. */
struct variable **split; /* SPLIT FILE vars. */
size_t split_cnt; /* SPLIT FILE count. */
size_t vector_cnt; /* Number of vectors. */
};
+
+
+
+
+int
+compare_long_names(const void *a_, const void *b_, void *aux UNUSED)
+{
+ const struct name_table_entry *a = a_;
+ const struct name_table_entry *b = b_;
+
+ return strcasecmp(a->longname, b->longname);
+}
+
+
+/* Long names use case insensitive comparison */
+unsigned int
+hash_long_name (const void *e_, void *aux UNUSED)
+{
+ const struct name_table_entry *e = e_;
+ unsigned int hash;
+ int i;
+
+ char *s = strdup(e->longname);
+
+ for ( i = 0 ; i < strlen(s) ; ++i )
+ s[i] = toupper(s[i]);
+
+ hash = hsh_hash_string (s);
+
+ free (s);
+
+ return hash;
+}
+
+static char *make_short_name(struct dictionary *dict, const char *longname) ;
+
+
/* Creates and returns a new dictionary. */
struct dictionary *
dict_create (void)
d->var = NULL;
d->var_cnt = d->var_cap = 0;
- d->name_tab = hsh_create (8, compare_variables, hash_variable, NULL, NULL);
+ d->name_tab = hsh_create (8, compare_var_names, hash_var_name, NULL, NULL);
+ d->long_name_tab = hsh_create (8, compare_long_names, hash_long_name, NULL, NULL);
d->next_value_idx = 0;
d->split = NULL;
d->split_cnt = 0;
{
struct dictionary *d;
size_t i;
-
+
assert (s != NULL);
-
+
d = dict_create ();
+
for (i = 0; i < s->var_cnt; i++)
- dict_clone_var (d, s->var[i], s->var[i]->name);
+ dict_clone_var (d, s->var[i], s->var[i]->name, s->var[i]->longname);
+
d->next_value_idx = s->next_value_idx;
d->split_cnt = s->split_cnt;
for (i = 0; i < d->var_cnt; i++)
{
struct variable *v = d->var[i];
+ var_clear_aux (v);
val_labs_destroy (v->val_labs);
free (v->label);
free (v);
d->var = NULL;
d->var_cnt = d->var_cap = 0;
hsh_clear (d->name_tab);
+ if ( d->long_name_tab)
+ hsh_clear (d->long_name_tab);
d->next_value_idx = 0;
free (d->split);
d->split = NULL;
dict_clear_vectors (d);
}
+/* Allocate the pointer TEXT and fill it with text representing the
+ long variable name buffer. SIZE will contain the size of TEXT.
+ TEXT must be freed by the caller when no longer required.
+*/
+void
+dict_get_varname_block(const struct dictionary *dict, char **text, int *size)
+{
+ char *buf = 0;
+ int bufsize = 0;
+ struct hsh_iterator hi;
+ struct name_table_entry *nte;
+ short first = 1;
+
+ for ( nte = hsh_first(dict->long_name_tab, &hi);
+ nte;
+ nte = hsh_next(dict->long_name_tab, &hi))
+ {
+ bufsize += strlen(nte->name) + strlen(nte->longname) + 2;
+ buf = xrealloc(buf, bufsize + 1);
+ if ( first )
+ strcpy(buf, "");
+ first = 0;
+
+ strcat(buf, nte->name);
+ strcat(buf, "=");
+ strcat(buf, nte->longname);
+ strcat(buf, "\t");
+ }
+
+ if ( bufsize > 0 )
+ {
+ /* Loose the final delimiting TAB */
+ buf[bufsize]='\0';
+ bufsize--;
+ }
+
+ *text = buf;
+ *size = bufsize;
+}
+
+
+/* Add a new entry into the dictionary's long name table, and update the
+ corresponding varible with the relevant long name.
+*/
+void
+dict_add_longvar_entry(struct dictionary *d,
+ const char *name,
+ const char *longname)
+{
+ struct variable *v;
+ assert ( name ) ;
+ assert ( longname );
+ struct name_table_entry *nte = xmalloc (sizeof (struct name_table_entry));
+ nte->longname = strdup(longname);
+ nte->name = strdup(name);
+
+
+ /* Look up the name in name_tab */
+ v = hsh_find ( d->name_tab, name);
+ if ( !v )
+ {
+ msg (FE, _("The entry \"%s\" in the variable name map, has no corresponding variable"), name);
+ return ;
+ }
+ assert ( 0 == strcmp(v->name, name) );
+ v->longname = nte->longname;
+
+ hsh_insert(d->long_name_tab, nte);
+
+
+}
+
+/* Destroys the aux data for every variable in D, by calling
+ var_clear_aux() for each variable. */
+void
+dict_clear_aux (struct dictionary *d)
+{
+ int i;
+
+ assert (d != NULL);
+
+ for (i = 0; i < d->var_cnt; i++)
+ var_clear_aux (d->var[i]);
+}
+
/* Clears a dictionary and destroys it. */
void
dict_destroy (struct dictionary *d)
{
dict_clear (d);
hsh_destroy (d->name_tab);
+ hsh_destroy (d->long_name_tab);
free (d);
}
}
assert (*cnt == count);
}
-/* Creates and returns a new variable in D with the given NAME
- and WIDTH. Returns a null pointer if the given NAME would
- duplicate that of an existing variable in the dictionary. */
+
+static struct variable * dict_create_var_x (struct dictionary *d,
+ const char *name, int width,
+ short name_is_short) ;
+
+/* Creates and returns a new variable in D with the given LONGNAME
+ and WIDTH. Returns a null pointer if the given LONGNAME would
+ duplicate that of an existing variable in the dictionary.
+*/
+struct variable *
+dict_create_var (struct dictionary *d, const char *longname, int width)
+{
+ return dict_create_var_x(d, longname, width, 0);
+}
+
+
+/* Creates and returns a new variable in D with the given SHORTNAME and
+ WIDTH. The long name table is not updated */
struct variable *
-dict_create_var (struct dictionary *d, const char *name, int width)
+dict_create_var_from_short (struct dictionary *d, const char *shortname,
+ int width)
+{
+ return dict_create_var_x(d, shortname, width, 1);
+}
+
+
+
+/* Creates and returns a new variable in D with the given NAME
+ and WIDTH.
+ If NAME_IS_SHORT, assume NAME is the short name. Otherwise assumes
+ NAME is the long name, and creates the corresponding entry in the
+ Dictionary's lookup name table .
+ Returns a null pointer if the given NAME would
+ duplicate that of an existing variable in the dictionary.
+
+*/
+static struct variable *
+dict_create_var_x (struct dictionary *d, const char *name, int width,
+ short name_is_short)
{
struct variable *v;
assert (d != NULL);
assert (name != NULL);
- assert (strlen (name) >= 1 && strlen (name) <= 8);
+
+ assert (strlen (name) >= 1);
+
assert (width >= 0 && width < 256);
+
+ if ( name_is_short )
+ assert(strlen (name) <= SHORT_NAME_LEN);
+ else
+ assert(strlen (name) <= LONG_NAME_LEN);
/* Make sure there's not already a variable by that name. */
if (dict_lookup_var (d, name) != NULL)
/* Allocate and initialize variable. */
v = xmalloc (sizeof *v);
- strncpy (v->name, name, sizeof v->name);
- v->name[8] = '\0';
+
+ if ( name_is_short )
+ {
+ strncpy (v->name, name, sizeof v->name);
+ v->name[SHORT_NAME_LEN] = '\0';
+ }
+ else
+ strcpy(v->name,make_short_name(d, name));
+
+
v->index = d->var_cnt;
v->type = width == 0 ? NUMERIC : ALPHA;
v->width = width;
v->fv = d->next_value_idx;
v->nv = width == 0 ? 1 : DIV_RND_UP (width, 8);
v->init = 1;
- v->reinit = dict_class_from_id (name) != DC_SCRATCH;
+ v->reinit = dict_class_from_id (v->name) != DC_SCRATCH;
v->miss_type = MISSING_NONE;
if (v->type == NUMERIC)
{
v->print.type = FMT_F;
v->print.w = 8;
v->print.d = 2;
+
+ v->alignment = ALIGN_RIGHT;
+ v->display_width = 8;
+ v->measure = MEASURE_SCALE;
}
else
{
v->print.type = FMT_A;
v->print.w = v->width;
v->print.d = 0;
+
+ v->alignment = ALIGN_LEFT;
+ v->display_width = 8;
+ v->measure = MEASURE_NOMINAL;
}
v->write = v->print;
v->val_labs = val_labs_create (v->width);
v->label = NULL;
+ v->aux = NULL;
+ v->aux_dtor = NULL;
/* Update dictionary. */
if (d->var_cnt >= d->var_cap)
d->var[v->index] = v;
d->var_cnt++;
hsh_force_insert (d->name_tab, v);
+
+ if ( ! name_is_short)
+ dict_add_longvar_entry(d, v->name, name);
+
d->next_value_idx += v->nv;
return v;
and WIDTH. Assert-fails if the given NAME would duplicate
that of an existing variable in the dictionary. */
struct variable *
-dict_create_var_assert (struct dictionary *d, const char *name, int width)
+dict_create_var_assert (struct dictionary *d, const char *longname, int width)
{
- struct variable *v = dict_create_var (d, name, width);
+ struct variable *v = dict_create_var (d, longname, width);
assert (v != NULL);
return v;
}
-/* Creates a new variable in D named NAME, as a copy of existing
- variable OV, which need not be in D or in any dictionary. */
+/* Creates a new variable in D with longname LONGNAME, as a copy of
+ existing variable OV, which need not be in D or in any
+ dictionary.
+ If SHORTNAME is non null, it will be used as the short name
+ otherwise a new short name will be generated.
+*/
struct variable *
dict_clone_var (struct dictionary *d, const struct variable *ov,
- const char *name)
+ const char *name, const char *longname)
{
struct variable *nv;
assert (d != NULL);
assert (ov != NULL);
- assert (name != NULL);
- assert (strlen (name) >= 1 && strlen (name) <= 8);
+ assert (strlen (longname) <= LONG_NAME_LEN);
+
+ struct name_table_entry *nte = xmalloc (sizeof (struct name_table_entry));
- nv = dict_create_var (d, name, ov->width);
+ nte->longname = strdup(longname);
+ if ( name )
+ {
+ assert (strlen (name) >= 1);
+ assert (strlen (name) <= SHORT_NAME_LEN);
+ nte->name = strdup(name);
+ }
+ else
+ nte->name = make_short_name(d, longname);
+
+
+ nv = dict_create_var_from_short (d, nte->name, ov->width);
if (nv == NULL)
return NULL;
+ hsh_insert(d->long_name_tab, nte);
+ nv->longname = nte->longname;
+
nv->init = 1;
nv->reinit = ov->reinit;
nv->miss_type = ov->miss_type;
if (ov->label != NULL)
nv->label = xstrdup (ov->label);
+ nv->alignment = ov->alignment;
+ nv->measure = ov->measure;
+ nv->display_width = ov->display_width;
+
return nv;
}
assert (d != NULL);
assert (v != NULL);
assert (new_name != NULL);
- assert (strlen (new_name) >= 1 && strlen (new_name) <= 8);
+ assert (strlen (new_name) >= 1 && strlen (new_name) <= SHORT_NAME_LEN);
+ assert (dict_contains_var (d, v));
if (!strcmp (v->name, new_name))
return;
hsh_force_delete (d->name_tab, v);
strncpy (v->name, new_name, sizeof v->name);
- v->name[8] = '\0';
+ v->name[SHORT_NAME_LEN] = '\0';
hsh_force_insert (d->name_tab, v);
}
dict_lookup_var (const struct dictionary *d, const char *name)
{
struct variable v;
+ struct variable *vr;
+ char *short_name;
+ struct name_table_entry key;
+ struct name_table_entry *nte;
+
assert (d != NULL);
assert (name != NULL);
- assert (strlen (name) >= 1 && strlen (name) <= 8);
+ assert (strlen (name) >= 1 && strlen (name) <= LONG_NAME_LEN);
+
+ key.longname = name;
+ nte = hsh_find (d->long_name_tab, &key);
+
+ if ( ! nte )
+ {
+ return 0;
+ }
- strncpy (v.name, name, sizeof v.name);
- v.name[8] = '\0';
+ short_name = nte->name ;
- return hsh_find (d->name_tab, &v);
+ strncpy (v.name, short_name, sizeof v.name);
+ v.name[SHORT_NAME_LEN] = '\0';
+
+ vr = hsh_find (d->name_tab, &v);
+
+ return vr;
}
+
/* Returns the variable named NAME in D. Assert-fails if no
variable has that name. */
struct variable *
assert (d != NULL);
assert (v != NULL);
- return dict_lookup_var (d, v->name) == v;
+ return v->index >= 0 && v->index < d->var_cnt && d->var[v->index] == v;
}
/* Compares two double pointers to variables, which should point
to elements of a struct dictionary's `var' member array. */
static int
-compare_variable_dblptrs (const void *a_, const void *b_, void *aux UNUSED)
+compare_var_ptrs (const void *a_, const void *b_, void *aux UNUSED)
{
struct variable *const *a = a_;
struct variable *const *b = b_;
- if (a > b)
- return 1;
- else if (a < b)
- return -1;
- else
- return 0;
+ return *a < *b ? -1 : *a > *b;
}
/* Deletes variable V from dictionary D and frees V.
assert (dict_contains_var (d, v));
assert (d->var[v->index] == v);
- /* Remove v from splits, weight, filter variables. */
+ /* Delete aux data. */
+ var_clear_aux (v);
+
+ /* Remove V from splits, weight, filter variables. */
d->split_cnt = remove_equal (d->split, d->split_cnt, sizeof *d->split,
- &v,
- compare_variable_dblptrs, NULL);
+ &v, compare_var_ptrs, NULL);
if (d->weight == v)
d->weight = NULL;
if (d->filter == v)
d->filter = NULL;
dict_clear_vectors (d);
- /* Remove v from var array. */
+ /* Remove V from var array. */
+ remove_element (d->var, d->var_cnt, sizeof *d->var, v->index);
d->var_cnt--;
- memmove (d->var + v->index, d->var + v->index + 1,
- (d->var_cnt - v->index) * sizeof *d->var);
/* Update index. */
for (i = v->index; i < d->var_cnt; i++)
size_t i;
int success = 1;
+
assert (d != NULL);
assert (count == 0 || vars != NULL);
assert (count == 0 || new_names != NULL);
+
old_names = xmalloc (count * sizeof *old_names);
for (i = 0; i < count; i++)
{
for (i = 0; i < count; i++)
{
+ struct name_table_entry key;
+ struct name_table_entry *nte;
assert (new_names[i] != NULL);
assert (*new_names[i] != '\0');
- assert (strlen (new_names[i]) < 9);
- strcpy (vars[i]->name, new_names[i]);
- if (hsh_insert (d->name_tab, vars[i]) != NULL)
+ assert (strlen (new_names[i]) <= LONG_NAME_LEN );
+ strcpy (vars[i]->name, make_short_name(d, new_names[i]));
+
+
+ key.longname = vars[i]->longname;
+ nte = hsh_find (d->long_name_tab, &key);
+
+ free( nte->longname ) ;
+ nte->longname = strdup ( new_names[i]);
+ vars[i]->longname = nte->longname;
+
+ if (hsh_insert (d->name_tab, vars[i]) != NULL )
{
size_t fail_idx = i;
if (err_name != NULL)
{
strcpy (vars[i]->name, old_names[i]);
hsh_force_insert (d->name_tab, vars[i]);
+
+ key.longname = vars[i]->longname;
+ nte = hsh_find (d->long_name_tab, &key);
+
+ free( nte->longname ) ;
+ nte->longname = strdup ( old_names[i]);
+ vars[i]->longname = nte->longname;
+
}
success = 0;
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. */
+/* 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 nonzero. The function will set warn_on_invalid to zero
+ if an invalid weight is found. */
double
-dict_get_case_weight (const struct dictionary *d, const struct ccase *c)
+dict_get_case_weight (const struct dictionary *d, const struct ccase *c,
+ int *warn_on_invalid)
{
assert (d != NULL);
assert (c != NULL);
return 1.0;
else
{
- double w = c->data[d->weight->fv].f;
- if (w < 0.0)
+ double w = case_num (c, d->weight->fv);
+ if ( w < 0.0 || w == SYSMIS || is_num_user_missing(w, d->weight) )
w = 0.0;
+ if ( w == 0.0 && *warn_on_invalid ) {
+ *warn_on_invalid = 0;
+ 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 sizeof (union value) * dict_get_next_value_idx (d);
}
-/* Reassigns values in dictionary D so that fragmentation is
- eliminated. */
+/* Deletes scratch variables in dictionary D and reassigns values
+ 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; )
+ {
+ struct variable *v = d->var[i];
+
+ if (dict_class_from_id (v->name) != DC_SCRATCH)
+ {
+ v->fv = d->next_value_idx;
+ d->next_value_idx += v->nv;
+ i++;
+ }
+ else
+ dict_delete_var (default_dict, v);
+ }
+}
+
+/* Copies values from SRC, which represents a case arranged
+ according to dictionary D, to DST, which represents a case
+ arranged according to the dictionary that will be produced by
+ dict_compact_values(D). */
+void
+dict_compact_case (const struct dictionary *d,
+ struct ccase *dst, const struct ccase *src)
+{
+ size_t i;
+ size_t value_idx;
+
+ value_idx = 0;
+ for (i = 0; i < d->var_cnt; i++)
+ {
+ struct variable *v = d->var[i];
+
+ if (dict_class_from_id (v->name) != DC_SCRATCH)
+ {
+ case_copy (dst, value_idx, src, v->fv, v->nv);
+ value_idx += v->nv;
+ }
+ }
+}
+
+/* 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)
+{
+ size_t i;
+ size_t cnt;
+
+ cnt = 0;
+ for (i = 0; i < d->var_cnt; i++)
+ if (dict_class_from_id (d->var[i]->name) != DC_SCRATCH)
+ cnt += d->var[i]->nv;
+ return cnt;
+}
+
+/* Creates and returns an array mapping from a dictionary index
+ to the `fv' that the corresponding variable will have after
+ calling dict_compact_values(). Scratch variables receive -1
+ for `fv' because dict_compact_values() will delete them. */
+int *
+dict_get_compacted_idx_to_fv (const struct dictionary *d)
+{
+ size_t i;
+ size_t next_value_idx;
+ int *idx_to_fv;
+
+ idx_to_fv = xmalloc (d->var_cnt * sizeof *idx_to_fv);
+ next_value_idx = 0;
for (i = 0; i < d->var_cnt; i++)
{
struct variable *v = d->var[i];
- v->fv = d->next_value_idx;
- d->next_value_idx += v->nv;
+ if (dict_class_from_id (v->name) != DC_SCRATCH)
+ {
+ idx_to_fv[i] = next_value_idx;
+ next_value_idx += v->nv;
+ }
+ else
+ idx_to_fv[i] = -1;
}
+ return idx_to_fv;
}
/* Returns the SPLIT FILE vars (see cmd_split_file()). Call
assert (d != NULL);
assert (name != NULL);
- assert (strlen (name) > 0 && strlen (name) < 9);
+ assert (strlen (name) > 0 && strlen (name) <= SHORT_NAME_LEN );
assert (var != NULL);
assert (cnt > 0);
d->vector = xrealloc (d->vector, (d->vector_cnt + 1) * sizeof *d->vector);
vector = d->vector[d->vector_cnt] = xmalloc (sizeof *vector);
vector->idx = d->vector_cnt++;
- strncpy (vector->name, name, 8);
- vector->name[8] = '\0';
+ strncpy (vector->name, name, SHORT_NAME_LEN);
+ vector->name[SHORT_NAME_LEN] = '\0';
vector->var = xmalloc (cnt * sizeof *var);
memcpy (vector->var, var, cnt * sizeof *var);
vector->cnt = cnt;
d->vector = NULL;
d->vector_cnt = 0;
}
+
+
+static const char * quasi_base27(int i);
+
+
+/* Convert I to quasi base 27
+ The result is a staticly allocated string.
+*/
+static const char *
+quasi_base27(int i)
+{
+ static char result[SHORT_NAME_LEN + 1];
+ static char reverse[SHORT_NAME_LEN + 1];
+
+ /* FIXME: check the result cant overflow these arrays */
+
+ char *s = result ;
+ const int radix = 27;
+ int units;
+
+ /* and here's the quasi-ness of this routine */
+ i = i + ( i / radix );
+
+ strcpy(result,"");
+ do {
+ units = i % radix;
+ *s++ = (units > 0 ) ? units + 'A' - 1 : 'A';
+ i = i / radix;
+ } while (i > 0 ) ;
+ *s = '\0';
+
+ /* Reverse the result */
+ i = strlen(result);
+ s = reverse;
+ while(i >= 0)
+ *s++ = result[--i];
+ *s = '\0';
+
+ return reverse;
+}
+
+
+/* Generate a short name, given a long name.
+ The return value of this function must be freed by the caller.
+*/
+static char *
+make_short_name(struct dictionary *dict, const char *longname)
+{
+ int i = 0;
+ char *p;
+
+
+ char *d = xmalloc ( SHORT_NAME_LEN + 1);
+
+ /* Truncate the name */
+ strncpy(d, longname, SHORT_NAME_LEN);
+ d[SHORT_NAME_LEN] = '\0';
+
+ /* Convert to upper case */
+ for ( p = d; *p ; ++p )
+ *p = toupper(*p);
+
+ /* If a variable with that name already exists, then munge it
+ until there's no conflict */
+ while (0 != hsh_find (dict->name_tab, d))
+ {
+ const char *suffix = quasi_base27(i++);
+
+ d[SHORT_NAME_LEN - strlen(suffix) - 1 ] = '_';
+ d[SHORT_NAME_LEN - strlen(suffix) ] = '\0';
+ strcat(d, suffix);
+ }
+
+ return d;
+}
+
+
+
+
projects / pspp-builds.git / blobdiff