X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fstats%2Fautorecode.c;h=66afb13afaba92e5df8791048292b279539c98ce;hb=b1b2d40a74005efbc4aa09609cc3bea4e2c16410;hp=fdf3dddc2ea83cec64daff9f394f34c40978b4e6;hpb=9ade26c8349b4434008c46cf09bc7473ec743972;p=pspp diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c index fdf3dddc2e..66afb13afa 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, 2014 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 @@ -16,28 +16,31 @@ #include +#include #include #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 +60,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,14 +73,20 @@ enum arc_direction DESCENDING }; +struct rec_items +{ + struct hmap ht; /* Hash table of "struct arc_item"s. */ +}; + + + /* AUTORECODE data. */ struct autorecode_pgm { struct arc_spec *specs; size_t n_specs; - /* Hash table of "struct arc_item"s. */ - struct hmap *global_items; + bool blank_valid; }; static trns_proc_func autorecode_trns_proc; @@ -84,39 +94,46 @@ static trns_free_func autorecode_trns_free; static int compare_arc_items (const void *, const void *, const void *aux); 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 struct arc_item *find_arc_item ( + const struct rec_items *, const union value *, int width, + size_t hash); + +/* Returns WIDTH with any trailing spaces in VALUE trimmed off (except that a + minimum width of 1 is always returned because otherwise the width would + indicate a numeric type). */ +static int +value_trim_spaces (const union value *value, int width) +{ + while (width > 1 && value->s[width - 1] == ' ') + width--; + return width; +} /* Performs the AUTORECODE procedure. */ int cmd_autorecode (struct lexer *lexer, struct dataset *ds) { - struct autorecode_pgm *arc = NULL; struct dictionary *dict = dataset_dict (ds); const struct variable **src_vars = NULL; - char **dst_names = NULL; size_t n_srcs = 0; + + char **dst_names = NULL; size_t n_dsts = 0; enum arc_direction direction = ASCENDING; - bool print = true; - - struct casereader *input; - struct ccase *c; - - size_t i; - bool ok; /* Create procedure. */ - arc = xzalloc (sizeof *arc); + struct autorecode_pgm *arc = xzalloc (sizeof *arc); + arc->blank_valid = true; /* Parse variable lists. */ lex_match_id (lexer, "VARIABLES"); 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; + lex_match (lexer, T_SLASH); if (!lex_force_match_id (lexer, "INTO")) goto error; lex_match (lexer, T_EQUALS); @@ -131,7 +148,7 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) goto error; } - for (i = 0; i < n_dsts; i++) + for (size_t i = 0; i < n_dsts; i++) { const char *name = dst_names[i]; @@ -144,17 +161,39 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) } /* Parse options. */ + bool group = false; 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")) + group = true; + else if (lex_match_id (lexer, "BLANK")) { - arc->global_items = xmalloc (sizeof (*arc->global_items)); - hmap_init (arc->global_items); + 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 + { + lex_error_expecting (lexer, "VALID", "MISSING"); + goto error; + } } + else + { + lex_error_expecting (lexer, "DESCENDING", "PRINT", "GROUP", "BLANK"); + goto error; + } } if (lex_token (lexer) != T_ENDCMD) @@ -163,51 +202,80 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) goto error; } + /* If GROUP is specified, verify that the variables are all string or all + numeric. */ + if (group) + { + enum val_type type = var_get_type (src_vars[0]); + for (size_t i = 1; i < n_dsts; i++) + { + if (var_get_type (src_vars[i]) != type) + { + size_t string_idx = type == VAL_STRING ? 0 : i; + size_t numeric_idx = type == VAL_STRING ? i : 0; + lex_error (lexer, _("With GROUP, variables may not mix string " + "variables (such as %s) and numeric " + "variables (such as %s)."), + var_get_name (src_vars[string_idx]), + var_get_name (src_vars[numeric_idx])); + goto error; + } + } + } + + /* Allocate all the specs and the rec_items that they point to. + + If GROUP is specified, there is only a single global rec_items, with the + maximum width 'width', and all of the specs point to it; otherwise each + spec has its own rec_items. */ arc->specs = xmalloc (n_dsts * sizeof *arc->specs); arc->n_specs = n_dsts; - - for (i = 0; i < n_dsts; i++) + for (size_t i = 0; i < n_dsts; i++) { struct arc_spec *spec = &arc->specs[i]; - spec->src = src_vars[i]; - if (arc->global_items) - { - spec->items = arc->global_items; - } + spec->width = var_get_width (src_vars[i]); + spec->src_idx = var_get_case_index (src_vars[i]); + + if (group && i > 0) + spec->items = arc->specs[0].items; else { - spec->items = xmalloc (sizeof (*spec->items)); - hmap_init (spec->items); + spec->items = xzalloc (sizeof (*spec->items)); + hmap_init (&spec->items->ht); } } - /* Execute procedure. */ - input = proc_open (ds); + struct casereader *input = proc_open (ds); + struct ccase *c; for (; (c = casereader_read (input)) != NULL; case_unref (c)) - for (i = 0; i < arc->n_specs; i++) + for (size_t 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); + const union value *value = case_data_idx (c, spec->src_idx); + int width = value_trim_spaces (value, spec->width); + if (width == 1 && value->s[0] == ' ' && !arc->blank_valid) + continue; + size_t hash = value_hash (value, width, 0); - struct arc_item *item; - - item = find_arc_item (spec, value, hash); - if (item == NULL) - { - item = xmalloc (sizeof *item); - item->width = width; - value_clone (&item->from, value, width); - hmap_insert (spec->items, &item->hmap_node, hash); - } + if (find_arc_item (spec->items, value, width, hash)) + continue; + + struct arc_item *item = xmalloc (sizeof *item); + item->width = width; + value_clone (&item->from, value, width); + hmap_insert (&spec->items->ht, &item->hmap_node, hash); } - ok = casereader_destroy (input); + bool 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++) + for (size_t i = 0; i < arc->n_specs; i++) { struct arc_spec *spec = &arc->specs[i]; struct arc_item **items; @@ -219,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); @@ -231,41 +299,37 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) sort (items, n_items, sizeof *items, compare_arc_items, NULL); /* Assign recoded values in sorted order. */ + for (j = 0; j < n_items; j++) + items[j]->to = direction == ASCENDING ? j + 1 : n_items - j; + + /* Add value labels to the destination variable which indicate + the source value from whence the new value comes. */ 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; - value_init (&to_val, 0); - - items[j]->to = direction == ASCENDING ? j + 1 : n_items - j; - - to_val.f = items[j]->to; - - /* Add value labels to the destination variable which indicate - the source value from whence the new value comes. */ + char *recoded_value; if (src_width > 0) { - const char *str = CHAR_CAST_BUG (const char*, value_str (from, src_width)); + const char *str = CHAR_CAST_BUG (const char *, from->s); - 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); - - /* Remove trailing whitespace */ - for (c = recoded_value; *c != '\0'; c++) - if ( *c == ' ') - { - *c = '\0'; - break; - } - - var_add_value_label (spec->dst, &to_val, recoded_value); - value_destroy (&to_val, 0); + recoded_value = c_xasprintf ("%.*g", DBL_DIG + 1, from->f); + + /* Remove trailing whitespace. */ + size_t len = strlen (recoded_value); + while (len > 0 && recoded_value[len - 1] == ' ') + recoded_value[--len] = '\0'; + + /* Add value label, if it would be nonempty. */ + if (len) + { + union value to_val = { .f = items[j]->to }; + var_add_value_label (spec->dst, &to_val, recoded_value); + } free (recoded_value); } @@ -274,10 +338,15 @@ cmd_autorecode (struct lexer *lexer, struct dataset *ds) } add_transformation (ds, autorecode_trns_proc, autorecode_trns_free, arc); + for (size_t i = 0; i < n_dsts; i++) + free (dst_names[i]); + free (dst_names); + free (src_vars); + return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; error: - for (i = 0; i < n_dsts; i++) + for (size_t i = 0; i < n_dsts; i++) free (dst_names[i]); free (dst_names); free (src_vars); @@ -290,37 +359,29 @@ arc_free (struct autorecode_pgm *arc) { if (arc != NULL) { - size_t i; - - for (i = 0; i < arc->n_specs; i++) + for (size_t i = 0; i < arc->n_specs; i++) { struct arc_spec *spec = &arc->specs[i]; 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 + size_t n_rec_items = + (arc->n_specs == 1 || arc->specs[0].items == arc->specs[1].items + ? 1 + : arc->n_specs); + for (size_t i = 0; i < n_rec_items; i++) { - for (i = 0; i < arc->n_specs; i++) - { - struct arc_spec *spec = &arc->specs[i]; - if (spec->items) - { - hmap_destroy (spec->items); - free (spec->items); - } - } + struct arc_spec *spec = &arc->specs[i]; + hmap_destroy (&spec->items->ht); + free (spec->items); } free (arc->specs); @@ -329,13 +390,14 @@ arc_free (struct autorecode_pgm *arc) } static struct arc_item * -find_arc_item (const struct arc_spec *spec, const union value *value, +find_arc_item (const struct rec_items *items, + const union value *value, int width, size_t hash) { 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, &items->ht) + if (item->width == width && value_equal (value, &item->from, width)) return item; return NULL; } @@ -357,8 +419,8 @@ compare_arc_items (const void *a_, const void *b_, const void *aux UNUSED) if ( width_b == 0 && width_a != 0) return +1; - return buf_compare_rpad (CHAR_CAST_BUG (const char *, value_str (&(*a)->from, width_a)), width_a, - CHAR_CAST_BUG (const char *, value_str (&(*b)->from, width_b)), width_b); + return buf_compare_rpad (CHAR_CAST_BUG (const char *, (*a)->from.s), width_a, + CHAR_CAST_BUG (const char *, (*b)->from.s), width_b); } static int @@ -366,17 +428,16 @@ autorecode_trns_proc (void *arc_, struct ccase **c, casenumber case_idx UNUSED) { struct autorecode_pgm *arc = arc_; - size_t i; *c = case_unshare (*c); - for (i = 0; i < arc->n_specs; i++) + for (size_t 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; - - item = find_arc_item (spec, value, value_hash (value, width, 0)); + const union value *value = case_data_idx (*c, spec->src_idx); + int width = value_trim_spaces (value, spec->width); + size_t hash = value_hash (value, width, 0); + const struct arc_item *item = find_arc_item (spec->items, value, width, + hash); case_data_rw (*c, spec->dst)->f = item ? item->to : SYSMIS; }