X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fautorecode.c;h=7c1b766750fb4319218c34a7ff8a30f47e9cc6fe;hb=3b9dfd387fdcbf5c2eb3c1a578990b58f4157ea5;hp=2a72aaea82ecd266a1e6a81bbd5857fdecd52e54;hpb=a258e53c63a08b0ec48aea8f03808eb651729424;p=pspp diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c index 2a72aaea82..7c1b766750 100644 --- a/src/language/stats/autorecode.c +++ b/src/language/stats/autorecode.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2009, 2010, 2012, 2013 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 @@ -20,24 +20,26 @@ #include "data/case.h" #include "data/casereader.h" +#include "data/dataset.h" #include "data/dictionary.h" -#include "data/procedure.h" #include "data/transformations.h" #include "data/variable.h" #include "language/command.h" #include "language/lexer/lexer.h" #include "language/lexer/variable-parser.h" #include "libpspp/array.h" -#include "libpspp/i18n.h" #include "libpspp/compiler.h" #include "libpspp/hash-functions.h" #include "libpspp/hmap.h" +#include "libpspp/i18n.h" #include "libpspp/message.h" #include "libpspp/pool.h" #include "libpspp/str.h" #include "gl/xalloc.h" -#include "gl/vasnprintf.h" +#include "gl/c-xvasprintf.h" +#include "gl/mbiter.h" + #include "gettext.h" #define _(msgid) gettext (msgid) @@ -57,9 +59,10 @@ struct arc_item /* Explains how to recode an AUTORECODE variable. */ struct arc_spec { - const struct variable *src; /* Source variable. */ + int width; /* Variable width. */ + int src_idx; /* Case index of source variable. */ struct variable *dst; /* Target variable. */ - struct hmap *items; /* Hash table of "struct arc_item"s. */ + struct rec_items *items; }; /* Descending or ascending sort order. */ @@ -69,6 +72,14 @@ enum arc_direction DESCENDING }; +struct rec_items +{ + struct hmap ht; /* Hash table of "struct arc_item"s. */ + int refcnt; +}; + + + /* AUTORECODE data. */ struct autorecode_pgm { @@ -76,7 +87,9 @@ struct autorecode_pgm size_t n_specs; /* Hash table of "struct arc_item"s. */ - struct hmap *global_items; + struct rec_items *global_items; + + bool blank_valid; }; static trns_proc_func autorecode_trns_proc; @@ -87,20 +100,41 @@ static void arc_free (struct autorecode_pgm *); static struct arc_item *find_arc_item (const struct arc_spec *, const union value *, size_t hash); +static bool +value_is_blank (const union value *val, int width, const struct dictionary *dict) +{ + mbi_iterator_t iter; + const char *str = CHAR_CAST_BUG (const char*, value_str (val, width)); + char *text = recode_string (UTF8, dict_get_encoding (dict), str, width); + + for (mbi_init (iter, text, width); mbi_avail (iter); mbi_advance (iter)) + { + mbchar_t c = mbi_cur (iter); + + if ( ! mb_isblank (c)) + { + free (text); + return false; + } + } + + free (text); + return true; +} + /* Performs the AUTORECODE procedure. */ int cmd_autorecode (struct lexer *lexer, struct dataset *ds) { struct autorecode_pgm *arc = NULL; - struct dictionary *dict = dataset_dict (ds); + struct dictionary *dict = dataset_dict (ds); const struct variable **src_vars = NULL; char **dst_names = NULL; size_t n_srcs = 0; size_t n_dsts = 0; enum arc_direction direction = ASCENDING; - bool print = true; struct casereader *input; struct ccase *c; @@ -110,17 +144,19 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) /* Create procedure. */ arc = xzalloc (sizeof *arc); + arc->blank_valid = true; /* Parse variable lists. */ lex_match_id (lexer, "VARIABLES"); - lex_match (lexer, '='); + lex_match (lexer, T_EQUALS); if (!parse_variables_const (lexer, dict, &src_vars, &n_srcs, - PV_NO_DUPLICATE)) + PV_NO_DUPLICATE | PV_NO_SCRATCH)) goto error; if (!lex_force_match_id (lexer, "INTO")) goto error; - lex_match (lexer, '='); - if (!parse_DATA_LIST_vars (lexer, &dst_names, &n_dsts, PV_NO_DUPLICATE)) + lex_match (lexer, T_EQUALS); + if (!parse_DATA_LIST_vars (lexer, dict, &dst_names, &n_dsts, + PV_NO_DUPLICATE)) goto error; if (n_dsts != n_srcs) { @@ -143,20 +179,39 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) } /* Parse options. */ - while (lex_match (lexer, '/')) + while (lex_match (lexer, T_SLASH)) { if (lex_match_id (lexer, "DESCENDING")) direction = DESCENDING; else if (lex_match_id (lexer, "PRINT")) - print = true; + { + /* Not yet implemented. */ + } else if (lex_match_id (lexer, "GROUP")) { arc->global_items = xmalloc (sizeof (*arc->global_items)); - hmap_init (arc->global_items); + arc->global_items->refcnt = 1; + hmap_init (&arc->global_items->ht); } + else if (lex_match_id (lexer, "BLANK")) + { + lex_match (lexer, T_EQUALS); + if (lex_match_id (lexer, "VALID")) + { + arc->blank_valid = true; + } + else if (lex_match_id (lexer, "MISSING")) + { + arc->blank_valid = false; + } + else + goto error; + } + else + goto error; } - if (lex_token (lexer) != '.') + if (lex_token (lexer) != T_ENDCMD) { lex_error (lexer, _("expecting end of command")); goto error; @@ -165,19 +220,24 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) arc->specs = xmalloc (n_dsts * sizeof *arc->specs); arc->n_specs = n_dsts; + for (i = 0; i < n_dsts; i++) { struct arc_spec *spec = &arc->specs[i]; - spec->src = src_vars[i]; + spec->width = var_get_width (src_vars[i]); + spec->src_idx = var_get_case_index (src_vars[i]); + if (arc->global_items) { + arc->global_items->refcnt++; spec->items = arc->global_items; } else { - spec->items = xmalloc (sizeof (*spec->items)); - hmap_init (spec->items); + spec->items = xzalloc (sizeof (*spec->items)); + spec->items->refcnt = 1; + hmap_init (&spec->items->ht); } } @@ -188,23 +248,32 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) for (i = 0; i < arc->n_specs; i++) { struct arc_spec *spec = &arc->specs[i]; - int width = var_get_width (spec->src); - const union value *value = case_data (c, spec->src); + int width = spec->width; + const union value *value = case_data_idx (c, spec->src_idx); size_t hash = value_hash (value, width, 0); struct arc_item *item; item = find_arc_item (spec, value, hash); - if (item == NULL) + if ( (item == NULL) + && + ( arc->blank_valid + || val_type_from_width (spec->width) == VAL_NUMERIC + || ! value_is_blank (value, width, dict)) + ) { item = xmalloc (sizeof *item); item->width = width; value_clone (&item->from, value, width); - hmap_insert (spec->items, &item->hmap_node, hash); + hmap_insert (&spec->items->ht, &item->hmap_node, hash); } } ok = casereader_destroy (input); ok = proc_commit (ds) && ok; + /* Re-fetch dictionary because it might have changed (if TEMPORARY was in + use). */ + dict = dataset_dict (ds); + /* Create transformation. */ for (i = 0; i < arc->n_specs; i++) { @@ -218,10 +287,10 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) spec->dst = dict_create_var_assert (dict, dst_names[i], 0); /* Create array of pointers to items. */ - n_items = hmap_count (spec->items); + n_items = hmap_count (&spec->items->ht); items = xmalloc (n_items * sizeof *items); j = 0; - HMAP_FOR_EACH (item, struct arc_item, hmap_node, spec->items) + HMAP_FOR_EACH (item, struct arc_item, hmap_node, &spec->items->ht) items[j++] = item; assert (j == n_items); @@ -233,11 +302,11 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) for (j = 0; j < n_items; j++) { const union value *from = &items[j]->from; - size_t len; char *recoded_value = NULL; - char *c; const int src_width = items[j]->width; union value to_val; + size_t len; + value_init (&to_val, 0); items[j]->to = direction == ASCENDING ? j + 1 : n_items - j; @@ -250,18 +319,16 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) { const char *str = CHAR_CAST_BUG (const char*, value_str (from, src_width)); - recoded_value = recode_string (UTF8, dict_get_encoding (dict), str, src_width); + recoded_value = recode_string (UTF8, dict_get_encoding (dict), + str, src_width); } else - recoded_value = asnprintf (NULL, &len, "%g", from->f); + recoded_value = c_xasprintf ("%g", from->f); /* Remove trailing whitespace */ - for (c = recoded_value; *c != '\0'; c++) - if ( *c == ' ') - { - *c = '\0'; - break; - } + len = strlen (recoded_value); + while (len > 0 && recoded_value[len - 1] == ' ') + recoded_value[--len] = '\0'; var_add_value_label (spec->dst, &to_val, recoded_value); value_destroy (&to_val, 0); @@ -273,6 +340,11 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) } add_transformation (ds, autorecode_trns_proc, autorecode_trns_free, arc); + for (i = 0; i < n_dsts; i++) + free (dst_names[i]); + free (dst_names); + free (src_vars); + return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; error: @@ -297,31 +369,31 @@ arc_free (struct autorecode_pgm *arc) struct arc_item *item, *next; HMAP_FOR_EACH_SAFE (item, next, struct arc_item, hmap_node, - spec->items) + &spec->items->ht) { value_destroy (&item->from, item->width); - hmap_delete (spec->items, &item->hmap_node); + hmap_delete (&spec->items->ht, &item->hmap_node); free (item); } } - if (arc->global_items) - { - free (arc->global_items); - } - else + for (i = 0; i < arc->n_specs; i++) { - for (i = 0; i < arc->n_specs; i++) + struct arc_spec *spec = &arc->specs[i]; + + if (--spec->items->refcnt == 0) { - struct arc_spec *spec = &arc->specs[i]; - if (spec->items) - { - hmap_destroy (spec->items); - free (spec->items); - } + hmap_destroy (&spec->items->ht); + free (spec->items); } } + if (arc->global_items && --arc->global_items->refcnt == 0) + { + hmap_destroy (&arc->global_items->ht); + free (arc->global_items); + } + free (arc->specs); free (arc); } @@ -333,8 +405,8 @@ find_arc_item (const struct arc_spec *spec, const union value *value, { struct arc_item *item; - HMAP_FOR_EACH_WITH_HASH (item, struct arc_item, hmap_node, hash, spec->items) - if (value_equal (value, &item->from, var_get_width (spec->src))) + HMAP_FOR_EACH_WITH_HASH (item, struct arc_item, hmap_node, hash, &spec->items->ht) + if (value_equal (value, &item->from, spec->width)) return item; return NULL; } @@ -371,11 +443,10 @@ autorecode_trns_proc (void *arc_, struct ccase **c, for (i = 0; i < arc->n_specs; i++) { const struct arc_spec *spec = &arc->specs[i]; - int width = var_get_width (spec->src); - const union value *value = case_data (*c, spec->src); - struct arc_item *item; + const union value *value = case_data_idx (*c, spec->src_idx); + unsigned int hash = value_hash (value, spec->width, 0); + const struct arc_item *item = find_arc_item (spec, value, hash); - item = find_arc_item (spec, value, value_hash (value, width, 0)); case_data_rw (*c, spec->dst)->f = item ? item->to : SYSMIS; }