X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=bca92dabe300b4c34439845c47abf485c900a778;hb=fd674641880b82597fa35492207f189136e83fbb;hp=02c6aa76bc5c991a2bc077ed9bc91a3e60972eea;hpb=38c2638eed90f33225870563c4be183097e4155a;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index 02c6aa76bc..bca92dabe3 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 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. */ @@ -63,11 +65,53 @@ struct dictionary 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) + { + free (d->encoding); + 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; +} + +/* 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. */ void @@ -78,7 +122,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)); @@ -144,7 +188,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++) @@ -181,6 +225,9 @@ 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; @@ -203,6 +250,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); @@ -334,10 +382,12 @@ 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); - d->next_value_idx += var_get_value_cnt (v); + d->next_value_idx++; + invalidate_proto (d); return v; } @@ -363,27 +413,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); @@ -461,6 +530,7 @@ 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); } @@ -503,7 +573,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)); @@ -535,9 +605,11 @@ 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); + 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 @@ -614,7 +686,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++) { @@ -666,6 +738,7 @@ dict_rename_var (struct dictionary *d, struct variable *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); } @@ -905,6 +978,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, @@ -933,6 +1007,7 @@ dict_set_filter (struct dictionary *d, struct variable *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, @@ -959,6 +1034,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. */ @@ -991,37 +1085,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), @@ -1047,10 +1115,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 @@ -1087,6 +1183,7 @@ dict_unset_split_var (struct dictionary *d, struct variable *v) &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) @@ -1114,6 +1211,7 @@ dict_set_split_vars (struct dictionary *d, 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); } @@ -1187,7 +1285,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. */ @@ -1299,7 +1397,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. */ @@ -1328,6 +1426,10 @@ dict_var_changed (const struct variable *v) const struct vardict_info *vdi = var_get_vardict (v); struct dictionary *d = vdi->dict; + if ( NULL == d) + return; + + 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); } @@ -1337,7 +1439,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)) { @@ -1346,10 +1448,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); } } @@ -1365,6 +1469,7 @@ dict_var_display_width_changed (const struct variable *v) d = vdi->dict; + 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); }