X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=f69d91e3605ed246302740c74e1cb2f47ef3d8f7;hb=33e610616a2b48f9a7eb56c4ebb0325b66df0376;hp=2dd1dfc4641108a08deb9b3e054acb7e872e53da;hpb=8ef8acb7c70a321963d30f2264e8f91e16427fcf;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index 2dd1dfc464..f69d91e360 100644 --- a/src/data/dictionary.c +++ b/src/data/dictionary.c @@ -1,5 +1,5 @@ /* 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 @@ -51,6 +51,8 @@ struct dictionary { 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. */ @@ -98,6 +100,14 @@ dict_set_change_callback (struct dictionary *d, 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. */ @@ -109,7 +119,7 @@ dict_dump (const struct dictionary *d) { 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)); @@ -175,7 +185,7 @@ dict_clone (const struct dictionary *s) 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++) @@ -237,6 +247,7 @@ dict_clear (struct dictionary *d) 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); @@ -372,7 +383,8 @@ add_var (struct dictionary *d, struct variable *v) 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; } @@ -398,27 +410,46 @@ dict_create_var_assert (struct dictionary *d, const char *name, int width) 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); @@ -539,7 +570,7 @@ 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); + const int width = var_get_width (v); assert (dict_contains_var (d, v)); @@ -572,8 +603,10 @@ dict_delete_var (struct dictionary *d, struct variable *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 @@ -650,7 +683,7 @@ dict_reorder_vars (struct dictionary *d, 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++) { @@ -998,6 +1031,25 @@ dict_set_case_limit (struct dictionary *d, casenumber case_limit) 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. */ @@ -1030,37 +1082,11 @@ dict_compact_values (struct dictionary *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); - } -} - -/* - 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); + set_var_case_index (v, d->next_value_idx++); } - - d->next_value_idx += padding; + invalidate_proto (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), @@ -1086,10 +1112,38 @@ dict_count_values (const struct dictionary *d, unsigned int exclude_classes) { 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; +} /* Returns the SPLIT FILE vars (see cmd_split_file()). Call dict_get_split_cnt() to determine how many SPLIT FILE vars @@ -1228,7 +1282,7 @@ dict_add_document_line (struct dictionary *d, const char *line) 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. */ @@ -1340,7 +1394,7 @@ dict_clear_vectors (struct dictionary *d) 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. */ @@ -1382,7 +1436,7 @@ dict_var_changed (const struct variable *v) /* 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)) { @@ -1391,11 +1445,12 @@ dict_var_resized (const struct variable *v, int delta) 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); } }