X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Flanguage%2Fstats%2Fautorecode.c;h=72534c76ea74cac4a7e0982dc57051be70f007b9;hb=e66ec694c4237bbc9e77bb3822a333377318ef94;hp=e808359bb17f5cc45cb57336476456c4708b46ac;hpb=81fff61a96bece351e381ad3fef8ab1248a952ba;p=pspp-builds.git diff --git a/src/language/stats/autorecode.c b/src/language/stats/autorecode.c index e808359b..72534c76 100644 --- a/src/language/stats/autorecode.c +++ b/src/language/stats/autorecode.c @@ -1,6 +1,5 @@ /* PSPP - computes sample statistics. Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. - Written by Ben Pfaff . This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as @@ -27,6 +26,7 @@ #include #include #include +#include #include #include #include @@ -40,10 +40,17 @@ /* FIXME: Implement PRINT subcommand. */ +/* An AUTORECODE variable's original value. */ +union arc_value + { + double f; /* Numeric. */ + char *c; /* Short or long string. */ + }; + /* Explains how to recode one value. `from' must be first element. */ struct arc_item { - union value from; /* Original value. */ + union arc_value from; /* Original value. */ double to; /* Recoded value. */ }; @@ -76,7 +83,7 @@ struct autorecode_pgm struct variable **src_vars; /* Source variables. */ char **dst_names; /* Target variable names. */ struct variable **dst_vars; /* Target variables. */ - struct hsh_table **src_values; /* `union value's of source vars. */ + struct hsh_table **src_values; /* `union arc_value's of source vars. */ size_t var_cnt; /* Number of variables. */ struct pool *src_values_pool; /* Pool used by src_values. */ enum direction direction; /* Sort order. */ @@ -85,16 +92,16 @@ struct autorecode_pgm static trns_proc_func autorecode_trns_proc; static trns_free_func autorecode_trns_free; -static bool autorecode_proc_func (struct ccase *, void *); +static bool autorecode_proc_func (const struct ccase *, void *, const struct dataset *); static hsh_compare_func compare_alpha_value, compare_numeric_value; static hsh_hash_func hash_alpha_value, hash_numeric_value; -static void recode (const struct autorecode_pgm *); +static void recode (struct dataset *, const struct autorecode_pgm *); static void arc_free (struct autorecode_pgm *); /* Performs the AUTORECODE procedure. */ int -cmd_autorecode (void) +cmd_autorecode (struct lexer *lexer, struct dataset *ds) { struct autorecode_pgm arc; size_t dst_cnt; @@ -111,15 +118,15 @@ cmd_autorecode (void) arc.print = 0; dst_cnt = 0; - lex_match_id ("VARIABLES"); - lex_match ('='); - if (!parse_variables (default_dict, &arc.src_vars, &arc.var_cnt, + lex_match_id (lexer, "VARIABLES"); + lex_match (lexer, '='); + if (!parse_variables (lexer, dataset_dict (ds), &arc.src_vars, &arc.var_cnt, PV_NO_DUPLICATE)) goto lossage; - if (!lex_force_match_id ("INTO")) + if (!lex_force_match_id (lexer, "INTO")) goto lossage; - lex_match ('='); - if (!parse_DATA_LIST_vars (&arc.dst_names, &dst_cnt, PV_NONE)) + lex_match (lexer, '='); + if (!parse_DATA_LIST_vars (lexer, &arc.dst_names, &dst_cnt, PV_NONE)) goto lossage; if (dst_cnt != arc.var_cnt) { @@ -136,14 +143,14 @@ cmd_autorecode (void) goto lossage; } - while (lex_match ('/')) - if (lex_match_id ("DESCENDING")) + while (lex_match (lexer, '/')) + if (lex_match_id (lexer, "DESCENDING")) arc.direction = DESCENDING; - else if (lex_match_id ("PRINT")) + else if (lex_match_id (lexer, "PRINT")) arc.print = 1; - if (token != '.') + if (lex_token (lexer) != '.') { - lex_error (_("expecting end of command")); + lex_error (lexer, _("expecting end of command")); goto lossage; } @@ -151,7 +158,7 @@ cmd_autorecode (void) { int j; - if (dict_lookup_var (default_dict, arc.dst_names[i]) != NULL) + if (dict_lookup_var (dataset_dict (ds), arc.dst_names[i]) != NULL) { msg (SE, _("Target variable %s duplicates existing variable %s."), arc.dst_names[i], arc.dst_names[i]); @@ -170,20 +177,20 @@ cmd_autorecode (void) arc.dst_vars = xnmalloc (arc.var_cnt, sizeof *arc.dst_vars); arc.src_values = xnmalloc (arc.var_cnt, sizeof *arc.src_values); for (i = 0; i < dst_cnt; i++) - if (arc.src_vars[i]->type == ALPHA) + if (var_is_alpha (arc.src_vars[i])) arc.src_values[i] = hsh_create (10, compare_alpha_value, hash_alpha_value, NULL, arc.src_vars[i]); else arc.src_values[i] = hsh_create (10, compare_numeric_value, hash_numeric_value, NULL, NULL); - ok = procedure (autorecode_proc_func, &arc); + ok = procedure (ds, autorecode_proc_func, &arc); for (i = 0; i < arc.var_cnt; i++) - arc.dst_vars[i] = dict_create_var_assert (default_dict, + arc.dst_vars[i] = dict_create_var_assert (dataset_dict (ds), arc.dst_names[i], 0); - recode (&arc); + recode (ds, &arc); arc_free (&arc); return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE; @@ -220,7 +227,7 @@ arc_free (struct autorecode_pgm *arc) /* AUTORECODE transformation. */ static void -recode (const struct autorecode_pgm *arc) +recode (struct dataset *ds, const struct autorecode_pgm *arc) { struct autorecode_trns *trns; size_t i; @@ -238,7 +245,7 @@ recode (const struct autorecode_pgm *arc) spec->src = arc->src_vars[i]; spec->dest = arc->dst_vars[i]; - if (arc->src_vars[i]->type == ALPHA) + if (var_is_alpha (arc->src_vars[i])) spec->items = hsh_create (2 * count, compare_alpha_value, hash_alpha_value, NULL, arc->src_vars[i]); else @@ -248,23 +255,24 @@ recode (const struct autorecode_pgm *arc) for (j = 0; *p; p++, j++) { struct arc_item *item = pool_alloc (trns->pool, sizeof *item); - union value *vp = *p; + union arc_value *vp = *p; - if (arc->src_vars[i]->type == NUMERIC) + if (var_is_numeric (arc->src_vars[i])) item->from.f = vp->f; else item->from.c = pool_clone (trns->pool, vp->c, - arc->src_vars[i]->width); + var_get_width (arc->src_vars[i])); item->to = arc->direction == ASCENDING ? j + 1 : count - j; hsh_force_insert (spec->items, item); } } - add_transformation (autorecode_trns_proc, autorecode_trns_free, trns); + add_transformation (ds, + autorecode_trns_proc, autorecode_trns_free, trns); } /* Executes an AUTORECODE transformation. */ static int -autorecode_trns_proc (void *trns_, struct ccase *c, int case_idx UNUSED) +autorecode_trns_proc (void *trns_, struct ccase *c, casenumber case_idx UNUSED) { struct autorecode_trns *trns = trns_; size_t i; @@ -273,15 +281,15 @@ autorecode_trns_proc (void *trns_, struct ccase *c, int case_idx UNUSED) { struct arc_spec *spec = &trns->specs[i]; struct arc_item *item; - union value v; + union arc_value v; - if (spec->src->type == NUMERIC) - v.f = case_num (c, spec->src->fv); + if (var_is_numeric (spec->src)) + v.f = case_num (c, spec->src); else - v.c = (char *) case_str (c, spec->src->fv); + v.c = (char *) case_str (c, spec->src); item = hsh_force_find (spec->items, &v); - case_data_rw (c, spec->dest->fv)->f = item->to; + case_data_rw (c, spec->dest)->f = item->to; } return TRNS_CONTINUE; } @@ -302,65 +310,65 @@ autorecode_trns_free (void *trns_) /* AUTORECODE procedure. */ static int -compare_alpha_value (const void *a_, const void *b_, void *v_) +compare_alpha_value (const void *a_, const void *b_, const void *v_) { - const union value *a = a_; - const union value *b = b_; + const union arc_value *a = a_; + const union arc_value *b = b_; const struct variable *v = v_; - return memcmp (a->c, b->c, v->width); + return memcmp (a->c, b->c, var_get_width (v)); } static unsigned -hash_alpha_value (const void *a_, void *v_) +hash_alpha_value (const void *a_, const void *v_) { - const union value *a = a_; + const union arc_value *a = a_; const struct variable *v = v_; - return hsh_hash_bytes (a->c, v->width); + return hsh_hash_bytes (a->c, var_get_width (v)); } static int -compare_numeric_value (const void *a_, const void *b_, void *foo UNUSED) +compare_numeric_value (const void *a_, const void *b_, const void *aux UNUSED) { - const union value *a = a_; - const union value *b = b_; + const union arc_value *a = a_; + const union arc_value *b = b_; return a->f < b->f ? -1 : a->f > b->f; } static unsigned -hash_numeric_value (const void *a_, void *foo UNUSED) +hash_numeric_value (const void *a_, const void *aux UNUSED) { - const union value *a = a_; + const union arc_value *a = a_; return hsh_hash_double (a->f); } static bool -autorecode_proc_func (struct ccase *c, void *arc_) +autorecode_proc_func (const struct ccase *c, void *arc_, const struct dataset *ds UNUSED) { struct autorecode_pgm *arc = arc_; size_t i; for (i = 0; i < arc->var_cnt; i++) { - union value v, *vp, **vpp; + union arc_value v, *vp, **vpp; - if (arc->src_vars[i]->type == NUMERIC) - v.f = case_num (c, arc->src_vars[i]->fv); + if (var_is_numeric (arc->src_vars[i])) + v.f = case_num (c, arc->src_vars[i]); else - v.c = (char *) case_str (c, arc->src_vars[i]->fv); + v.c = (char *) case_str (c, arc->src_vars[i]); - vpp = (union value **) hsh_probe (arc->src_values[i], &v); + vpp = (union arc_value **) hsh_probe (arc->src_values[i], &v); if (*vpp == NULL) { vp = pool_alloc (arc->src_values_pool, sizeof *vp); - if (arc->src_vars[i]->type == NUMERIC) + if (var_is_numeric (arc->src_vars[i])) vp->f = v.f; else vp->c = pool_clone (arc->src_values_pool, - v.c, arc->src_vars[i]->width); + v.c, var_get_width (arc->src_vars[i])); *vpp = vp; } }