X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Faggregate.c;h=47c60f344c53fbbd660d28903695c2f2170dfad2;hb=1f53043596e4f60c302974a83edbe2088fde4470;hp=47f34dcab440fc6fe81a573d512eb91398d8a8cf;hpb=843e8862e77bcc2813a944b6feb524ea6cc2ab6a;p=pspp-builds.git diff --git a/src/aggregate.c b/src/aggregate.c index 47f34dca..47c60f34 100644 --- a/src/aggregate.c +++ b/src/aggregate.c @@ -14,8 +14,8 @@ 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., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. */ #include #include "error.h" @@ -124,7 +124,7 @@ struct agr_proc struct sort_criteria *sort; /* Sort criteria. */ struct variable **break_vars; /* Break variables. */ size_t break_var_cnt; /* Number of break variables. */ - union value *prev_break; /* Last values of break variables. */ + struct ccase break_case; /* Last values of break variables. */ enum missing_treatment missing; /* How to treat missing values. */ struct agr_var *agr_vars; /* First aggregate variable. */ @@ -133,7 +133,8 @@ struct agr_proc struct ccase agr_case; /* Aggregate case for output. */ }; -static void initialize_aggregate_info (struct agr_proc *); +static void initialize_aggregate_info (struct agr_proc *, + const struct ccase *); /* Prototypes. */ static int parse_aggregate_functions (struct agr_proc *); @@ -164,6 +165,7 @@ cmd_aggregate (void) memset(&agr, 0 , sizeof (agr)); agr.missing = ITEMWISE; + case_nullify (&agr.break_case); agr.dict = dict_create (); dict_set_label (agr.dict, dict_get_label (default_dict)); @@ -211,11 +213,8 @@ cmd_aggregate (void) goto error; for (i = 0; i < agr.break_var_cnt; i++) - { - struct variable *v = dict_clone_var (agr.dict, agr.break_vars[i], - agr.break_vars[i]->name); - assert (v != NULL); - } + dict_clone_var_assert (agr.dict, agr.break_vars[i], + agr.break_vars[i]->name); /* BREAK must follow the options. */ break; @@ -246,7 +245,6 @@ cmd_aggregate (void) /* Initialize. */ agr.case_cnt = 0; case_create (&agr.agr_case, dict_get_next_value_idx (agr.dict)); - initialize_aggregate_info (&agr); /* Output to active file or external file? */ if (out_file == NULL) @@ -276,7 +274,7 @@ cmd_aggregate (void) } else { - agr.writer = sfm_open_writer (out_file, agr.dict, get_scompression ()); + agr.writer = sfm_open_writer (out_file, agr.dict, get_scompression (), 0); if (agr.writer == NULL) goto error; @@ -396,7 +394,7 @@ parse_aggregate_functions (struct agr_proc *agr) } for (function = agr_func_tab; function->name; function++) - if (!strcmp (function->name, tokid)) + if (!strcasecmp (function->name, tokid)) break; if (NULL == function->name) { @@ -452,7 +450,8 @@ parse_aggregate_functions (struct agr_proc *agr) arg[i].f = tokval; type = NUMERIC; } else { - msg (SE, _("Missing argument %d to %s."), i + 1, function->name); + msg (SE, _("Missing argument %d to %s."), i + 1, + function->name); goto error; } @@ -492,8 +491,7 @@ parse_aggregate_functions (struct agr_proc *agr) || func_index == FIN || func_index == FOUT) && ((src[0]->type == NUMERIC && arg[0].f > arg[1].f) || (src[0]->type == ALPHA - && st_compare_pad (arg[0].c, strlen (arg[0].c), - arg[1].c, strlen (arg[1].c)) > 0))) + && str_compare_rpad (arg[0].c, arg[1].c) > 0))) { union value t = arg[0]; arg[0] = arg[1]; @@ -524,7 +522,6 @@ parse_aggregate_functions (struct agr_proc *agr) /* Create the target variable in the aggregate dictionary. */ { - static const struct fmt_spec f8_2 = {FMT_F, 8, 2}; struct variable *destvar; v->function = func_index; @@ -541,20 +538,20 @@ parse_aggregate_functions (struct agr_proc *agr) if (function->alpha_type == ALPHA) destvar = dict_clone_var (agr->dict, v->src, dest[i]); - else if (v->src->type == NUMERIC - || function->alpha_type == NUMERIC) + else { + assert (v->src->type == NUMERIC + || function->alpha_type == NUMERIC); destvar = dict_create_var (agr->dict, dest[i], 0); - - if ((func_index == N || func_index == NMISS) - && dict_get_weight (default_dict) != NULL) - destvar->print = destvar->write = f8_2; - else - destvar->print = destvar->write = function->format; + if (destvar != NULL) + { + if ((func_index == N || func_index == NMISS) + && dict_get_weight (default_dict) != NULL) + destvar->print = destvar->write = f8_2; + else + destvar->print = destvar->write = function->format; + } } - else - destvar = dict_create_var (agr->dict, dest[i], - v->src->width); } else { v->src = NULL; destvar = dict_create_var (agr->dict, dest[i], 0); @@ -572,7 +569,6 @@ parse_aggregate_functions (struct agr_proc *agr) "the aggregate variables and the break " "variables."), dest[i]); - free (dest[i]); goto error; } @@ -655,7 +651,7 @@ agr_destroy (struct agr_proc *agr) if (agr->sort != NULL) sort_destroy_criteria (agr->sort); free (agr->break_vars); - free (agr->prev_break); + case_destroy (&agr->break_case); for (iter = agr->agr_vars; iter; iter = next) { next = iter->next; @@ -693,105 +689,21 @@ static int aggregate_single_case (struct agr_proc *agr, const struct ccase *input, struct ccase *output) { - /* The first case always begins a new break group. We also need to - preserve the values of the case for later comparison. */ + bool finished_group = false; + if (agr->case_cnt++ == 0) + initialize_aggregate_info (agr, input); + else if (case_compare (&agr->break_case, input, + agr->break_vars, agr->break_var_cnt)) { - int n_elem = 0; - - { - int i; + dump_aggregate_info (agr, output); + finished_group = true; - for (i = 0; i < agr->break_var_cnt; i++) - n_elem += agr->break_vars[i]->nv; - } - - agr->prev_break = xmalloc (sizeof *agr->prev_break * n_elem); - - /* Copy INPUT into prev_break. */ - { - union value *iter = agr->prev_break; - int i; - - for (i = 0; i < agr->break_var_cnt; i++) - { - struct variable *v = agr->break_vars[i]; - - if (v->type == NUMERIC) - (iter++)->f = case_num (input, v->fv); - else - { - memcpy (iter->s, case_str (input, v->fv), v->width); - iter += v->nv; - } - } - } - - accumulate_aggregate_info (agr, input); - - return 0; + initialize_aggregate_info (agr, input); } - - /* Compare the value of each break variable to the values on the - previous case. */ - { - union value *iter = agr->prev_break; - int i; - - for (i = 0; i < agr->break_var_cnt; i++) - { - struct variable *v = agr->break_vars[i]; - - switch (v->type) - { - case NUMERIC: - if (case_num (input, v->fv) != iter->f) - goto not_equal; - iter++; - break; - case ALPHA: - if (memcmp (case_str (input, v->fv), iter->s, v->width)) - goto not_equal; - iter += v->nv; - break; - default: - assert (0); - } - } - } - - accumulate_aggregate_info (agr, input); - return 0; - -not_equal: - /* The values of the break variable are different from the values on - the previous case. That means that it's time to dump aggregate - info. */ - dump_aggregate_info (agr, output); - initialize_aggregate_info (agr); accumulate_aggregate_info (agr, input); - - /* Copy INPUT into prev_break. */ - { - union value *iter = agr->prev_break; - int i; - - for (i = 0; i < agr->break_var_cnt; i++) - { - struct variable *v = agr->break_vars[i]; - - if (v->type == NUMERIC) - (iter++)->f = case_num (input, v->fv); - else - { - memcpy (iter->s, case_str (input, v->fv), v->width); - iter += v->nv; - } - } - } - - return 1; + return finished_group; } /* Accumulates aggregation data from the case INPUT. */ @@ -978,11 +890,11 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output) for (i = 0; i < agr->break_var_cnt; i++) { - int nv = agr->break_vars[i]->nv; + struct variable *v = agr->break_vars[i]; memcpy (case_data_rw (output, value_idx), - &agr->prev_break[value_idx], - sizeof (union value) * nv); - value_idx += nv; + case_data (&agr->break_case, v->fv), + sizeof (union value) * v->nv); + value_idx += v->nv; } } @@ -1098,10 +1010,13 @@ dump_aggregate_info (struct agr_proc *agr, struct ccase *output) /* Resets the state for all the aggregate functions. */ static void -initialize_aggregate_info (struct agr_proc *agr) +initialize_aggregate_info (struct agr_proc *agr, const struct ccase *input) { struct agr_var *iter; + case_destroy (&agr->break_case); + case_clone (&agr->break_case, input); + for (iter = agr->agr_vars; iter; iter = iter->next) { iter->missing = 0;