X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fdictionary.c;h=2eef7e72667cdab59ad5cf3f9add655ea136ee0e;hb=a444c32ff965e91abff74634375266064bff05a6;hp=f6776780fe7362a61ec1545fa8037dada890c8e4;hpb=8af88c0b7ea2fe75df7e45497988ed0371006a86;p=pspp diff --git a/src/data/dictionary.c b/src/data/dictionary.c index f6776780fe..2eef7e7266 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,6 +65,9 @@ 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 */ @@ -71,6 +76,24 @@ struct dictionary 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*), @@ -80,6 +103,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. */ @@ -91,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)); @@ -154,19 +185,14 @@ 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)); + 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; @@ -194,6 +220,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; @@ -216,6 +245,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); @@ -332,11 +362,13 @@ static struct variable * 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) @@ -351,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; } @@ -377,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); @@ -468,12 +520,9 @@ compare_var_ptrs (const void *a_, const void *b_, const void *aux UNUSED) /* 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 ) @@ -484,9 +533,7 @@ set_var_dict_index (struct variable *v, int dict_index) 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 @@ -497,7 +544,7 @@ reindex_vars (struct dictionary *d, size_t from, size_t to) 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. @@ -518,7 +565,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)); @@ -547,12 +594,15 @@ dict_delete_var (struct dictionary *d, struct variable *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 @@ -629,21 +679,21 @@ 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++) { 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); @@ -654,14 +704,14 @@ dict_reorder_vars (struct dictionary *d, 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 @@ -977,6 +1027,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. */ @@ -1009,37 +1078,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), @@ -1065,10 +1108,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 @@ -1207,7 +1278,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. */ @@ -1319,7 +1390,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. */ @@ -1348,6 +1419,9 @@ 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); @@ -1358,7 +1432,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)) { @@ -1367,11 +1441,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); } } @@ -1392,4 +1467,52 @@ dict_var_display_width_changed (const struct variable *v) d->callbacks->var_display_width_changed (d, var_get_dict_index (v), d->cb_data); } } + +/* 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; + } + } +}