X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fxforms%2Frecode.c;h=62b03ba073b9a5f6f6a1c5b282d9c26b0ce286b9;hb=a5097a183f00ab2d2dc538ba7094a4696e2fea04;hp=01f3bf765428038e9e964ee55e7ebe79c8b07fed;hpb=9f650fc3d2946c216e6cd3c7922a8a63d0f97117;p=pspp-builds.git diff --git a/src/language/xforms/recode.c b/src/language/xforms/recode.c index 01f3bf76..62b03ba0 100644 --- a/src/language/xforms/recode.c +++ b/src/language/xforms/recode.c @@ -1,20 +1,18 @@ -/* PSPP - computes sample statistics. - Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. +/* PSPP - a program for statistical analysis. + Copyright (C) 1997-9, 2000, 2009 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 the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + 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 + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ + along with this program. If not, see . */ #include @@ -24,23 +22,23 @@ #include #include +#include #include #include #include #include #include #include +#include #include -#include -#include #include #include -#include -#include #include #include #include +#include "xalloc.h" + #include "gettext.h" #define _(msgid) gettext (msgid) @@ -57,31 +55,24 @@ enum map_in_type MAP_CONVERT /* "123" => 123. */ }; -/* A value involved in a RECODE mapping. */ -union recode_value - { - double f; /* Numeric. */ - char *c; /* Short or long string. */ - }; - /* Describes input values to be mapped. */ struct map_in { enum map_in_type type; /* One of MAP_*. */ - union recode_value x, y; /* Source values. */ + union value x, y; /* Source values. */ }; /* Describes the value used as output from a mapping. */ -struct map_out +struct map_out { bool copy_input; /* If true, copy input to output. */ - union recode_value value; /* If copy_input false, recoded value. */ - int width; /* If copy_input false, output value width. */ + union value value; /* If copy_input false, recoded value. */ + int width; /* If copy_input false, output value width. */ }; /* Describes how to recode a single value or range of values into a single value. */ -struct mapping +struct mapping { struct map_in in; /* Input values. */ struct map_out out; /* Output value. */ @@ -92,19 +83,24 @@ struct recode_trns { struct pool *pool; + + /* Variable types, for convenience. */ - enum var_type src_type; /* src_vars[*]->type. */ - enum var_type dst_type; /* dst_vars[*]->type. */ + enum val_type src_type; /* src_vars[*] type. */ + enum val_type dst_type; /* dst_vars[*] type. */ /* Variables. */ - struct variable **src_vars; /* Source variables. */ - struct variable **dst_vars; /* Destination variables. */ + const struct variable **src_vars; /* Source variables. */ + const struct variable **dst_vars; /* Destination variables. */ + const struct dictionary *dst_dict; /* Dictionary of dst_vars */ char **dst_names; /* Name of dest variables, if they're new. */ size_t var_cnt; /* Number of variables. */ /* Mappings. */ struct mapping *mappings; /* Value mappings. */ size_t map_cnt; /* Number of mappings. */ + int max_src_width; /* Maximum width of src_vars[*]. */ + int max_dst_width; /* Maximum width of any map_out in mappings. */ }; static bool parse_src_vars (struct lexer *, struct recode_trns *, const struct dictionary *dict); @@ -115,7 +111,7 @@ static void add_mapping (struct recode_trns *, size_t *map_allocated, const struct map_in *); static bool parse_map_in (struct lexer *lexer, struct map_in *, struct pool *, - enum var_type src_type, size_t max_src_width); + enum val_type src_type, size_t max_src_width); static void set_map_in_generic (struct map_in *, enum map_in_type); static void set_map_in_num (struct map_in *, enum map_in_type, double, double); static void set_map_in_str (struct map_in *, struct pool *, @@ -156,21 +152,21 @@ cmd_recode (struct lexer *lexer, struct dataset *ds) /* Ensure that all the output strings are at least as wide as the widest destination variable. */ - if (trns->dst_type == VAR_STRING) + if (trns->dst_type == VAL_STRING) enlarge_dst_widths (trns); /* Create destination variables, if needed. This must be the final step; otherwise we'd have to delete destination variables on failure. */ if (trns->src_vars != trns->dst_vars) - create_dst_vars (trns, dataset_dict (ds)); + create_dst_vars (trns, dataset_dict (ds)); /* Done. */ - add_transformation (ds, + add_transformation (ds, recode_trns_proc, recode_trns_free, trns); } while (lex_match (lexer, '/')); - + return lex_end_of_command (lexer); } @@ -178,10 +174,10 @@ cmd_recode (struct lexer *lexer, struct dataset *ds) TRNS->var_cnt. Sets TRNS->src_type. Returns true if successful, false on parse error. */ static bool -parse_src_vars (struct lexer *lexer, - struct recode_trns *trns, const struct dictionary *dict) +parse_src_vars (struct lexer *lexer, + struct recode_trns *trns, const struct dictionary *dict) { - if (!parse_variables (lexer, dict, &trns->src_vars, &trns->var_cnt, + if (!parse_variables_const (lexer, dict, &trns->src_vars, &trns->var_cnt, PV_SAME_TYPE)) return false; pool_register (trns->pool, free, trns->src_vars); @@ -193,22 +189,21 @@ parse_src_vars (struct lexer *lexer, into TRNS->mappings and TRNS->map_cnt. Sets TRNS->dst_type. Returns true if successful, false on parse error. */ static bool -parse_mappings (struct lexer *lexer, struct recode_trns *trns) +parse_mappings (struct lexer *lexer, struct recode_trns *trns) { - size_t max_src_width; size_t map_allocated; bool have_dst_type; size_t i; - + /* Find length of longest source variable. */ - max_src_width = var_get_width (trns->src_vars[0]); - for (i = 1; i < trns->var_cnt; i++) + trns->max_src_width = var_get_width (trns->src_vars[0]); + for (i = 1; i < trns->var_cnt; i++) { size_t var_width = var_get_width (trns->src_vars[i]); - if (var_width > max_src_width) - max_src_width = var_width; + if (var_width > trns->max_src_width) + trns->max_src_width = var_width; } - + /* Parse the mappings in parentheses. */ trns->mappings = NULL; trns->map_cnt = 0; @@ -218,9 +213,9 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) return false; do { - enum var_type dst_type; + enum val_type dst_type; - if (!lex_match_id (lexer, "CONVERT")) + if (!lex_match_id (lexer, "CONVERT")) { struct map_out out; size_t first_map_idx; @@ -232,8 +227,9 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) do { struct map_in in; + if (!parse_map_in (lexer, &in, trns->pool, - trns->src_type, max_src_width)) + trns->src_type, trns->max_src_width)) return false; add_mapping (trns, &map_allocated, &in); lex_match (lexer, ','); @@ -242,7 +238,11 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) if (!parse_map_out (lexer, trns->pool, &out)) return false; - dst_type = var_type_from_width (out.width); + + if (out.copy_input) + dst_type = trns->src_type; + else + dst_type = val_type_from_width (out.width); if (have_dst_type && dst_type != trns->dst_type) { msg (SE, _("Inconsistent target variable types. " @@ -250,20 +250,21 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) "must be all numeric or all string.")); return false; } - + for (i = first_map_idx; i < trns->map_cnt; i++) trns->mappings[i].out = out; } - else + else { /* Parse CONVERT as a special case. */ struct map_in in; set_map_in_generic (&in, MAP_CONVERT); add_mapping (trns, &map_allocated, &in); - - dst_type = VAR_NUMERIC; - if (trns->src_type != VAR_STRING - || (have_dst_type && trns->dst_type != VAR_NUMERIC)) + set_map_out_num (&trns->mappings[trns->map_cnt - 1].out, 0.0); + + dst_type = VAL_NUMERIC; + if (trns->src_type != VAL_STRING + || (have_dst_type && trns->dst_type != VAL_NUMERIC)) { msg (SE, _("CONVERT requires string input values and " "numeric output values.")); @@ -274,7 +275,7 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) have_dst_type = true; if (!lex_force_match (lexer, ')')) - return false; + return false; } while (lex_match (lexer, '(')); @@ -288,17 +289,18 @@ parse_mappings (struct lexer *lexer, struct recode_trns *trns) false on parse error. */ static bool parse_map_in (struct lexer *lexer, struct map_in *in, struct pool *pool, - enum var_type src_type, size_t max_src_width) + enum val_type src_type, size_t max_src_width) { + if (lex_match_id (lexer, "ELSE")) set_map_in_generic (in, MAP_ELSE); - else if (src_type == VAR_NUMERIC) + else if (src_type == VAL_NUMERIC) { if (lex_match_id (lexer, "MISSING")) set_map_in_generic (in, MAP_MISSING); else if (lex_match_id (lexer, "SYSMIS")) set_map_in_generic (in, MAP_SYSMIS); - else + else { double x, y; if (!parse_num_range (lexer, &x, &y, NULL)) @@ -308,10 +310,21 @@ parse_map_in (struct lexer *lexer, struct map_in *in, struct pool *pool, } else { - if (!lex_force_string (lexer)) + if (lex_match_id (lexer, "MISSING")) + set_map_in_generic (in, MAP_MISSING); + else if (!lex_force_string (lexer)) return false; - set_map_in_str (in, pool, lex_tokstr (lexer), max_src_width); - lex_get (lexer); + else + { + set_map_in_str (in, pool, lex_tokstr (lexer), max_src_width); + lex_get (lexer); + if (lex_token (lexer) == T_ID + && lex_id_match (ss_cstr ("THRU"), ss_cstr (lex_tokid (lexer)))) + { + msg (SE, _("THRU is not allowed with string variables.")); + return false; + } + } } return true; @@ -335,7 +348,7 @@ add_mapping (struct recode_trns *trns, /* Sets IN as a mapping of the given TYPE. */ static void -set_map_in_generic (struct map_in *in, enum map_in_type type) +set_map_in_generic (struct map_in *in, enum map_in_type type) { in->type = type; } @@ -343,7 +356,7 @@ set_map_in_generic (struct map_in *in, enum map_in_type type) /* Sets IN as a numeric mapping of the given TYPE, with X and Y as the two numeric values. */ static void -set_map_in_num (struct map_in *in, enum map_in_type type, double x, double y) +set_map_in_num (struct map_in *in, enum map_in_type type, double x, double y) { in->type = type; in->x.f = x; @@ -355,11 +368,12 @@ set_map_in_num (struct map_in *in, enum map_in_type type, double x, double y) right to WIDTH characters long. */ static void set_map_in_str (struct map_in *in, struct pool *pool, - const struct string *string, size_t width) + const struct string *string, size_t width) { in->type = MAP_SINGLE; - in->x.c = pool_alloc_unaligned (pool, width); - buf_copy_rpad (in->x.c, width, ds_data (string), ds_length (string)); + value_init_pool (pool, &in->x, width); + value_copy_buf_rpad (&in->x, width, + ds_data (string), ds_length (string), ' '); } /* Parses a mapping output value into OUT, allocating memory from @@ -379,19 +393,22 @@ parse_map_out (struct lexer *lexer, struct pool *pool, struct map_out *out) set_map_out_str (out, pool, lex_tokstr (lexer)); lex_get (lexer); } - else if (lex_match_id (lexer, "COPY")) - out->copy_input = true; - else + else if (lex_match_id (lexer, "COPY")) + { + out->copy_input = true; + out->width = 0; + } + else { lex_error (lexer, _("expecting output value")); return false; } - return true; + return true; } /* Sets OUT as a numeric mapping output with the given VALUE. */ static void -set_map_out_num (struct map_out *out, double value) +set_map_out_num (struct map_out *out, double value) { out->copy_input = false; out->value.f = value; @@ -406,36 +423,44 @@ set_map_out_str (struct map_out *out, struct pool *pool, const char *string = ds_data (value); size_t length = ds_length (value); + if (length == 0) + { + /* A length of 0 will yield a numeric value, which is not + what we want. */ + string = " "; + length = 1; + } + out->copy_input = false; - out->value.c = pool_alloc_unaligned (pool, length); - memcpy (out->value.c, string, length); + value_init_pool (pool, &out->value, length); + memcpy (value_str_rw (&out->value, length), string, length); out->width = length; } /* Parses a set of target variables into TRNS->dst_vars and TRNS->dst_names. */ static bool -parse_dst_vars (struct lexer *lexer, struct recode_trns *trns, - const struct dictionary *dict) +parse_dst_vars (struct lexer *lexer, struct recode_trns *trns, + const struct dictionary *dict) { size_t i; - + if (lex_match_id (lexer, "INTO")) { size_t name_cnt; size_t i; - if (!parse_mixed_vars_pool (lexer, dict, trns->pool, + if (!parse_mixed_vars_pool (lexer, dict, trns->pool, &trns->dst_names, &name_cnt, PV_NONE)) return false; if (name_cnt != trns->var_cnt) { - msg (SE, _("%u variable(s) cannot be recoded into " - "%u variable(s). Specify the same number " + msg (SE, _("%zu variable(s) cannot be recoded into " + "%zu variable(s). Specify the same number " "of variables as source and target variables."), - (unsigned) trns->var_cnt, (unsigned) name_cnt); + trns->var_cnt, name_cnt); return false; } @@ -443,9 +468,9 @@ parse_dst_vars (struct lexer *lexer, struct recode_trns *trns, trns->var_cnt, sizeof *trns->dst_vars); for (i = 0; i < trns->var_cnt; i++) { - struct variable *v; + const struct variable *v; v = trns->dst_vars[i] = dict_lookup_var (dict, trns->dst_names[i]); - if (v == NULL && trns->dst_type == VAR_STRING) + if (v == NULL && trns->dst_type == VAL_STRING) { msg (SE, _("There is no variable named " "%s. (All string variables specified " @@ -456,28 +481,29 @@ parse_dst_vars (struct lexer *lexer, struct recode_trns *trns, return false; } } + } - else + else { trns->dst_vars = trns->src_vars; if (trns->src_type != trns->dst_type) { msg (SE, _("INTO is required with %s input values " "and %s output values."), - trns->src_type == VAR_NUMERIC ? _("numeric") : _("string"), - trns->dst_type == VAR_NUMERIC ? _("numeric") : _("string")); + trns->src_type == VAL_NUMERIC ? _("numeric") : _("string"), + trns->dst_type == VAL_NUMERIC ? _("numeric") : _("string")); return false; } } for (i = 0; i < trns->var_cnt; i++) { - struct variable *v = trns->dst_vars[i]; + const struct variable *v = trns->dst_vars[i]; if (v != NULL && var_get_type (v) != trns->dst_type) { msg (SE, _("Type mismatch. Cannot store %s data in " "%s variable %s."), - trns->dst_type == VAR_STRING ? _("string") : _("numeric"), + trns->dst_type == VAL_STRING ? _("string") : _("numeric"), var_is_alpha (v) ? _("string") : _("numeric"), var_get_name (v)); return false; @@ -490,28 +516,24 @@ parse_dst_vars (struct lexer *lexer, struct recode_trns *trns, /* Ensures that all the output values in TRNS are as wide as the widest destination variable. */ static void -enlarge_dst_widths (struct recode_trns *trns) +enlarge_dst_widths (struct recode_trns *trns) { - size_t max_dst_width; size_t i; - max_dst_width = 0; + trns->max_dst_width = 0; for (i = 0; i < trns->var_cnt; i++) { - struct variable *v = trns->dst_vars[i]; - if (var_get_width (v) > max_dst_width) - max_dst_width = var_get_width (v); + const struct variable *v = trns->dst_vars[i]; + if (var_get_width (v) > trns->max_dst_width) + trns->max_dst_width = var_get_width (v); } for (i = 0; i < trns->map_cnt; i++) { struct map_out *out = &trns->mappings[i].out; - if (!out->copy_input && out->width < max_dst_width) - { - char *s = pool_alloc_unaligned (trns->pool, max_dst_width + 1); - str_copy_rpad (s, max_dst_width + 1, out->value.c); - out->value.c = s; - } + if (!out->copy_input) + value_resize_pool (trns->pool, &out->value, + out->width, trns->max_dst_width); } } @@ -521,11 +543,13 @@ create_dst_vars (struct recode_trns *trns, struct dictionary *dict) { size_t i; - for (i = 0; i < trns->var_cnt; i++) + trns->dst_dict = dict; + + for (i = 0; i < trns->var_cnt; i++) { - struct variable **var = &trns->dst_vars[i]; + const struct variable **var = &trns->dst_vars[i]; const char *name = trns->dst_names[i]; - + *var = dict_lookup_var (dict, name); if (*var == NULL) *var = dict_create_var_assert (dict, name, 0); @@ -538,7 +562,7 @@ create_dst_vars (struct recode_trns *trns, struct dictionary *dict) /* Returns the output mapping in TRNS for an input of VALUE on variable V, or a null pointer if there is no mapping. */ static const struct map_out * -find_src_numeric (struct recode_trns *trns, double value, struct variable *v) +find_src_numeric (struct recode_trns *trns, double value, const struct variable *v) { struct mapping *m; @@ -547,18 +571,21 @@ find_src_numeric (struct recode_trns *trns, double value, struct variable *v) const struct map_in *in = &m->in; const struct map_out *out = &m->out; bool match; - + switch (in->type) { case MAP_SINGLE: match = value == in->x.f; break; case MAP_MISSING: - match = var_is_num_missing (v, value, MV_USER); + match = var_is_num_missing (v, value, MV_ANY); break; case MAP_RANGE: match = value >= in->x.f && value <= in->y.f; break; + case MAP_SYSMIS: + match = value == SYSMIS; + break; case MAP_ELSE: match = true; break; @@ -576,20 +603,23 @@ find_src_numeric (struct recode_trns *trns, double value, struct variable *v) /* Returns the output mapping in TRNS for an input of VALUE with the given WIDTH, or a null pointer if there is no mapping. */ static const struct map_out * -find_src_string (struct recode_trns *trns, const char *value, int width) +find_src_string (struct recode_trns *trns, const uint8_t *value, + const struct variable *src_var) { struct mapping *m; + int width = var_get_width (src_var); for (m = trns->mappings; m < trns->mappings + trns->map_cnt; m++) { const struct map_in *in = &m->in; struct map_out *out = &m->out; bool match; - + switch (in->type) { case MAP_SINGLE: - match = !memcmp (value, in->x.c, width); + match = !memcmp (value, value_str (&in->x, trns->max_src_width), + width); break; case MAP_ELSE: match = true; @@ -599,11 +629,15 @@ find_src_string (struct recode_trns *trns, const char *value, int width) union value uv; msg_disable (); - match = data_in (ss_buffer (value, width), FMT_F, 0, 0, &uv, 0); + match = data_in (ss_buffer (value, width), LEGACY_NATIVE, + FMT_F, 0, 0, 0, trns->dst_dict, &uv, 0); msg_enable (); out->value.f = uv.f; break; } + case MAP_MISSING: + match = var_is_str_missing (src_var, value, MV_ANY); + break; default: NOT_REACHED (); } @@ -617,45 +651,49 @@ find_src_string (struct recode_trns *trns, const char *value, int width) /* Performs RECODE transformation. */ static int -recode_trns_proc (void *trns_, struct ccase *c, casenumber case_idx UNUSED) +recode_trns_proc (void *trns_, struct ccase **c, casenumber case_idx UNUSED) { struct recode_trns *trns = trns_; size_t i; - for (i = 0; i < trns->var_cnt; i++) + *c = case_unshare (*c); + for (i = 0; i < trns->var_cnt; i++) { - struct variable *src_var = trns->src_vars[i]; - struct variable *dst_var = trns->dst_vars[i]; - - const union value *src_data = case_data (c, src_var); - union value *dst_data = case_data_rw (c, dst_var); - + const struct variable *src_var = trns->src_vars[i]; + const struct variable *dst_var = trns->dst_vars[i]; const struct map_out *out; - if (trns->src_type == VAR_NUMERIC) - out = find_src_numeric (trns, src_data->f, src_var); + if (trns->src_type == VAL_NUMERIC) + out = find_src_numeric (trns, case_num (*c, src_var), src_var); else - out = find_src_string (trns, src_data->s, var_get_width (src_var)); + out = find_src_string (trns, case_str (*c, src_var), src_var); - if (trns->dst_type == VAR_NUMERIC) + if (trns->dst_type == VAL_NUMERIC) { + double *dst = &case_data_rw (*c, dst_var)->f; if (out != NULL) - dst_data->f = !out->copy_input ? out->value.f : src_data->f; + *dst = !out->copy_input ? out->value.f : case_num (*c, src_var); else if (trns->src_vars != trns->dst_vars) - dst_data->f = SYSMIS; + *dst = SYSMIS; } - else + else { + char *dst = case_str_rw (*c, dst_var); if (out != NULL) { - if (!out->copy_input) - memcpy (dst_data->s, out->value.c, var_get_width (dst_var)); + if (!out->copy_input) + memcpy (dst, value_str (&out->value, trns->max_dst_width), + var_get_width (dst_var)); else if (trns->src_vars != trns->dst_vars) - buf_copy_rpad (dst_data->s, var_get_width (dst_var), - src_data->s, var_get_width (src_var)); + { + union value *dst_data = case_data_rw (*c, dst_var); + const union value *src_data = case_data (*c, src_var); + value_copy_rpad (dst_data, var_get_width (dst_var), + src_data, var_get_width (src_var), ' '); + } } else if (trns->src_vars != trns->dst_vars) - memset (dst_data->s, ' ', var_get_width (dst_var)); + memset (dst, ' ', var_get_width (dst_var)); } }