X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdata%2Fcasereader-filter.c;h=f4ad7e625a3e7ea79dfc91c4e93864eac78394d1;hb=69b31e124aff05df3492e6e6412c03c64e4e9d12;hp=5c46ed50dba436d1584a320e134be8fefc5e5de0;hpb=b65cf0519aa1db140d30c878978f29b1e23c9cd0;p=pspp diff --git a/src/data/casereader-filter.c b/src/data/casereader-filter.c index 5c46ed50db..f4ad7e625a 100644 --- a/src/data/casereader-filter.c +++ b/src/data/casereader-filter.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2007 Free Software Foundation, Inc. + Copyright (C) 2007, 2009, 2011 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,18 +16,18 @@ #include -#include +#include "data/casereader.h" #include -#include -#include -#include -#include -#include -#include +#include "data/casereader-provider.h" +#include "data/casewriter.h" +#include "data/variable.h" +#include "data/dictionary.h" +#include "libpspp/taint.h" +#include "libpspp/message.h" -#include "xalloc.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -78,7 +78,7 @@ casereader_create_filter_func (struct casereader *subreader, filter->aux = aux; filter->exclude = exclude; reader = casereader_create_sequential ( - NULL, casereader_get_value_cnt (filter->subreader), CASENUMBER_MAX, + NULL, casereader_get_proto (filter->subreader), CASENUMBER_MAX, &casereader_filter_class, filter); taint_propagate (casereader_get_taint (filter->subreader), casereader_get_taint (reader)); @@ -86,22 +86,22 @@ casereader_create_filter_func (struct casereader *subreader, } /* Internal read function for filtering casereader. */ -static bool -casereader_filter_read (struct casereader *reader UNUSED, void *filter_, - struct ccase *c) +static struct ccase * +casereader_filter_read (struct casereader *reader UNUSED, void *filter_) { struct casereader_filter *filter = filter_; for (;;) { - if (!casereader_read (filter->subreader, c)) - return false; + struct ccase *c = casereader_read (filter->subreader); + if (c == NULL) + return NULL; else if (filter->include (c, filter->aux)) - return true; + return c; else if (filter->exclude != NULL) casewriter_write (filter->exclude, c); else - case_destroy (c); + case_unref (c); } } @@ -115,12 +115,12 @@ casereader_filter_destroy (struct casereader *reader, void *filter_) casewriter, if there is one. */ if (filter->exclude != NULL) { - struct ccase c; - while (casereader_read (filter->subreader, &c)) - if (filter->include (&c, filter->aux)) - case_destroy (&c); + struct ccase *c; + while ((c = casereader_read (filter->subreader)) != NULL) + if (filter->include (c, filter->aux)) + case_unref (c); else - casewriter_write (filter->exclude, &c); + casewriter_write (filter->exclude, c); } casereader_destroy (filter->subreader); @@ -212,7 +212,7 @@ casereader_filter_weight_include (const struct ccase *c, void *cfw_) { struct casereader_filter_weight *cfw = cfw_; double value = case_num (c, cfw->weight_var); - if (value >= 0.0 && !var_is_num_missing (cfw->weight_var, value, MV_ANY)) + if (value >= 0.0 && !var_is_num_missing (cfw->weight_var, value)) return true; else { @@ -243,7 +243,7 @@ casereader_filter_weight_destroy (void *cfw_) struct casereader_filter_missing { struct variable **vars; /* Variables whose values to filter. */ - size_t var_cnt; /* Number of variables. */ + size_t n_vars; /* Number of variables. */ enum mv_class class; /* Types of missing values to filter. */ casenumber *n_missing; }; @@ -253,7 +253,7 @@ static bool casereader_filter_missing_destroy (void *); /* Creates and returns a casereader that filters out cases from READER that have a missing value in the given CLASS for any of - the VAR_CNT variables in VARS. Only cases that have + the N_VARS variables in VARS. Only cases that have non-missing values for all of these variables are passed through. @@ -273,20 +273,19 @@ static bool casereader_filter_missing_destroy (void *); when the filtering casereader is destroyed. */ struct casereader * casereader_create_filter_missing (struct casereader *reader, - const struct variable **vars, size_t var_cnt, + const struct variable *const *vars, size_t n_vars, enum mv_class class, casenumber *n_missing, struct casewriter *exclude) { - if (var_cnt > 0 && class != MV_NEVER) + if (n_vars > 0 && class) { struct casereader_filter_missing *cfm = xmalloc (sizeof *cfm); - cfm->vars = xmemdup (vars, sizeof *vars * var_cnt); - cfm->var_cnt = var_cnt; + cfm->vars = xmemdup (vars, sizeof *vars * n_vars); + cfm->n_vars = n_vars; cfm->class = class; cfm->n_missing = n_missing; - if (n_missing) - *n_missing = 0; + if (n_missing) *n_missing = 0; return casereader_create_filter_func (reader, casereader_filter_missing_include, casereader_filter_missing_destroy, @@ -305,13 +304,13 @@ casereader_filter_missing_include (const struct ccase *c, void *cfm_) const struct casereader_filter_missing *cfm = cfm_; size_t i; - for (i = 0; i < cfm->var_cnt; i++) + for (i = 0; i < cfm->n_vars; i++) { struct variable *var = cfm->vars[i]; const union value *value = case_data (c, var); - if (var_is_value_missing (var, value, cfm->class)) + if (var_is_value_missing (var, value) & cfm->class) { - if ( cfm->n_missing ) + if (cfm->n_missing) (*cfm->n_missing)++; return false; }