X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fmatrix-data.c;h=ee43d82f2ba2df94bc8cc94b9cd4119e5d8213ad;hb=e210b20bf6f405637c8c03dd280b5a4a627191b8;hp=b2adcd4a8f594fb18cc3bedf6a43d1ac3455ffe9;hpb=cc18840c1952a016935b95b8a139dd70f1ec619e;p=pspp-builds.git diff --git a/src/matrix-data.c b/src/matrix-data.c index b2adcd4a..ee43d82f 100644 --- a/src/matrix-data.c +++ b/src/matrix-data.c @@ -14,35 +14,21 @@ 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. */ -/* AIX requires this to be the first thing in the file. */ #include -#if __GNUC__ -#define alloca __builtin_alloca -#else -#if HAVE_ALLOCA_H -#include -#else -#ifdef _AIX -#pragma alloca -#else -#ifndef alloca /* predefined by HP cc +Olibcalls */ -char *alloca (); -#endif -#endif -#endif -#endif - -#include +#include "error.h" #include #include #include +#include "algorithm.h" #include "alloc.h" +#include "case.h" #include "command.h" #include "data-in.h" -#include "dfm.h" +#include "dfm-read.h" +#include "dictionary.h" #include "error.h" #include "file-handle.h" #include "lexer.h" @@ -52,20 +38,36 @@ char *alloca (); #include "var.h" #include "vfm.h" +#include "gettext.h" +#define _(msgid) gettext (msgid) + #include "debug-print.h" /* FIXME: /N subcommand not implemented. It should be pretty simple, too. */ -/* Format type enums. */ +/* Different types of variables for MATRIX DATA procedure. Order is + important: these are used for sort keys. */ enum + { + MXD_SPLIT, /* SPLIT FILE variables. */ + MXD_ROWTYPE, /* ROWTYPE_. */ + MXD_FACTOR, /* Factor variables. */ + MXD_VARNAME, /* VARNAME_. */ + MXD_CONTINUOUS, /* Continuous variables. */ + + MXD_COUNT + }; + +/* Format type enums. */ +enum format_type { LIST, FREE }; /* Matrix section enums. */ -enum +enum matrix_section { LOWER, UPPER, @@ -73,14 +75,14 @@ enum }; /* Diagonal inclusion enums. */ -enum +enum include_diagonal { DIAGONAL, NODIAGONAL }; /* CONTENTS types. */ -enum +enum content_type { N_VECTOR, N_SCALAR, @@ -101,7 +103,7 @@ enum }; /* 0=vector, 1=matrix, 2=scalar. */ -static int content_type[PROX + 1] = +static const int content_type[PROX + 1] = { 0, 2, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, }; @@ -113,81 +115,88 @@ static const char *content_names[PROX + 1] = "DFE", "MAT", "COV", "CORR", "PROX", }; -/* The data file to be read. */ -static struct file_handle *data_file; - -/* Format type. */ -static int fmt; /* LIST or FREE. */ -static int section; /* LOWER or UPPER or FULL. */ -static int diag; /* DIAGONAL or NODIAGONAL. */ - -/* Arena used for all the MATRIX DATA allocations. */ -static struct pool *container; - -/* ROWTYPE_ specified explicitly in data? */ -static int explicit_rowtype; +/* A MATRIX DATA input program. */ +struct matrix_data_pgm + { + struct pool *container; /* Arena used for all allocations. */ + struct dfm_reader *reader; /* Data file to read. */ -/* ROWTYPE_, VARNAME_ variables. */ -static struct variable *rowtype_, *varname_; + /* Format. */ + enum format_type fmt; /* LIST or FREE. */ + enum matrix_section section;/* LOWER or UPPER or FULL. */ + enum include_diagonal diag; /* DIAGONAL or NODIAGONAL. */ -/* Is is per-factor data? */ -int is_per_factor[PROX + 1]; + int explicit_rowtype; /* ROWTYPE_ specified explicitly in data? */ + struct variable *rowtype_, *varname_; /* ROWTYPE_, VARNAME_ variables. */ + + struct variable *single_split; /* Single SPLIT FILE variable. */ -/* Single SPLIT FILE variable. */ -static struct variable *single_split; + /* Factor variables. */ + size_t n_factors; /* Number of factor variables. */ + struct variable **factors; /* Factor variables. */ + int is_per_factor[PROX + 1]; /* Is there per-factor data? */ -/* Factor variables. */ -static int n_factors; -static struct variable **factors; + int cells; /* Number of cells, or -1 if none. */ -/* Number of cells, or -1 if none. */ -static int cells; + int pop_n; /* Population N specified by user. */ -/* Population N specified by user. */ -static int pop_n; + /* CONTENTS subcommand. */ + int contents[EOC * 3 + 1]; /* Contents. */ + int n_contents; /* Number of entries. */ -/* CONTENTS subcommand. */ -static int contents[EOC * 3 + 1]; -static int n_contents; + /* Continuous variables. */ + int n_continuous; /* Number of continuous variables. */ + int first_continuous; /* Index into default_dict.var of + first continuous variable. */ + }; -/* Number of continuous variables. */ -static int n_continuous; +/* Auxiliary data attached to MATRIX DATA variables. */ +struct mxd_var + { + int var_type; /* Variable type. */ + int sub_type; /* Subtype. */ + }; -/* Index into default_dict.var of first continuous variables. */ -static int first_continuous; +static const struct case_source_class matrix_data_with_rowtype_source_class; +static const struct case_source_class matrix_data_without_rowtype_source_class; -static int compare_variables_by_mxd_vartype (const void *pa, +static int compare_variables_by_mxd_var_type (const void *pa, const void *pb); -static void read_matrices_without_rowtype (void); -static void read_matrices_with_rowtype (void); +static void read_matrices_without_rowtype (struct matrix_data_pgm *); +static void read_matrices_with_rowtype (struct matrix_data_pgm *); static int string_to_content_type (char *, int *); - -#if DEBUGGING -static void debug_print (void); -#endif +static void attach_mxd_aux (struct variable *, int var_type, int sub_type); int cmd_matrix_data (void) { + struct pool *pool; + struct matrix_data_pgm *mx; + struct file_handle *fh = NULL; + unsigned seen = 0; - lex_match_id ("MATRIX"); - lex_match_id ("DATA"); - - container = pool_create (); - discard_variables (); - data_file = inline_file; - fmt = LIST; - section = LOWER; - diag = DIAGONAL; - single_split = NULL; - n_factors = 0; - factors = NULL; - cells = -1; - pop_n = -1; - n_contents = 0; + pool = pool_create (); + mx = pool_alloc (pool, sizeof *mx); + mx->container = pool; + mx->reader = NULL; + mx->fmt = LIST; + mx->section = LOWER; + mx->diag = DIAGONAL; + mx->explicit_rowtype = 0; + mx->rowtype_ = NULL; + mx->varname_ = NULL; + mx->single_split = NULL; + mx->n_factors = 0; + mx->factors = NULL; + memset (mx->is_per_factor, 0, sizeof mx->is_per_factor); + mx->cells = -1; + mx->pop_n = -1; + mx->n_contents = 0; + mx->n_continuous = 0; + mx->first_continuous = 0; while (token != '.') { lex_match ('/'); @@ -195,7 +204,7 @@ cmd_matrix_data (void) if (lex_match_id ("VARIABLES")) { char **v; - int nv; + size_t nv; if (seen & 1) { @@ -209,10 +218,10 @@ cmd_matrix_data (void) goto lossage; { - int i; + size_t i; for (i = 0; i < nv; i++) - if (!strcmp (v[i], "VARNAME_")) + if (!strcasecmp (v[i], "VARNAME_")) { msg (SE, _("VARNAME_ cannot be explicitly specified on " "VARIABLES.")); @@ -224,38 +233,33 @@ cmd_matrix_data (void) } { - int i; + size_t i; for (i = 0; i < nv; i++) { struct variable *new_var; - if (strcmp (v[i], "ROWTYPE_")) + if (strcasecmp (v[i], "ROWTYPE_")) { - new_var = force_create_variable (&default_dict, v[i], - NUMERIC, 0); - new_var->p.mxd.vartype = MXD_CONTINUOUS; - new_var->p.mxd.subtype = i; - } + new_var = dict_create_var_assert (default_dict, v[i], 0); + attach_mxd_aux (new_var, MXD_CONTINUOUS, i); + } else - explicit_rowtype = 1; + mx->explicit_rowtype = 1; free (v[i]); } free (v); } - { - rowtype_ = force_create_variable (&default_dict, "ROWTYPE_", - ALPHA, 8); - rowtype_->p.mxd.vartype = MXD_ROWTYPE; - rowtype_->p.mxd.subtype = 0; - } + mx->rowtype_ = dict_create_var_assert (default_dict, + "ROWTYPE_", 8); + attach_mxd_aux (mx->rowtype_, MXD_ROWTYPE, 0); } else if (lex_match_id ("FILE")) { lex_match ('='); - data_file = fh_parse_file_handle (); - if (!data_file) + fh = fh_parse (); + if (fh == NULL) goto lossage; } else if (lex_match_id ("FORMAT")) @@ -265,19 +269,19 @@ cmd_matrix_data (void) while (token == T_ID) { if (lex_match_id ("LIST")) - fmt = LIST; + mx->fmt = LIST; else if (lex_match_id ("FREE")) - fmt = FREE; + mx->fmt = FREE; else if (lex_match_id ("LOWER")) - section = LOWER; + mx->section = LOWER; else if (lex_match_id ("UPPER")) - section = UPPER; + mx->section = UPPER; else if (lex_match_id ("FULL")) - section = FULL; + mx->section = FULL; else if (lex_match_id ("DIAGONAL")) - diag = DIAGONAL; + mx->diag = DIAGONAL; else if (lex_match_id ("NODIAGONAL")) - diag = NODIAGONAL; + mx->diag = NODIAGONAL; else { lex_error (_("in FORMAT subcommand")); @@ -302,54 +306,53 @@ cmd_matrix_data (void) goto lossage; } - if (!is_varname (tokid) + if (dict_lookup_var (default_dict, tokid) == NULL && (lex_look_ahead () == '.' || lex_look_ahead () == '/')) { - if (!strcmp (tokid, "ROWTYPE_") || !strcmp (tokid, "VARNAME_")) + if (!strcasecmp (tokid, "ROWTYPE_") + || !strcasecmp (tokid, "VARNAME_")) { msg (SE, _("Split variable may not be named ROWTYPE_ " "or VARNAME_.")); goto lossage; } - single_split = force_create_variable (&default_dict, tokid, - NUMERIC, 0); + mx->single_split = dict_create_var_assert (default_dict, + tokid, 0); + attach_mxd_aux (mx->single_split, MXD_CONTINUOUS, 0); lex_get (); - single_split->p.mxd.vartype = MXD_CONTINUOUS; - - default_dict.n_splits = 1; - default_dict.splits = xmalloc (2 * sizeof *default_dict.splits); - default_dict.splits[0] = single_split; - default_dict.splits[1] = NULL; + dict_set_split_vars (default_dict, &mx->single_split, 1); } else { - struct variable **v; - int n; + struct variable **split; + size_t n; - if (!parse_variables (NULL, &v, &n, PV_NO_DUPLICATE)) + if (!parse_variables (default_dict, &split, &n, PV_NO_DUPLICATE)) goto lossage; - default_dict.n_splits = n; - default_dict.splits = v = xrealloc (v, sizeof *v * (n + 1)); - v[n] = NULL; + dict_set_split_vars (default_dict, split, n); } { - int i; - - for (i = 0; i < default_dict.n_splits; i++) - { - if (default_dict.splits[i]->p.mxd.vartype != MXD_CONTINUOUS) + struct variable *const *split = dict_get_split_vars (default_dict); + size_t split_cnt = dict_get_split_cnt (default_dict); + int i; + + for (i = 0; i < split_cnt; i++) + { + struct mxd_var *mv = split[i]->aux; + assert (mv != NULL); + if (mv->var_type != MXD_CONTINUOUS) { msg (SE, _("Split variable %s is already another type."), tokid); goto lossage; } - default_dict.splits[i]->p.mxd.vartype = MXD_SPLIT; - default_dict.splits[i]->p.mxd.subtype = i; - } + var_clear_aux (split[i]); + attach_mxd_aux (split[i], MXD_SPLIT, i); + } } } else if (lex_match_id ("FACTORS")) @@ -363,22 +366,26 @@ cmd_matrix_data (void) } seen |= 4; - if (!parse_variables (NULL, &factors, &n_factors, PV_NONE)) + if (!parse_variables (default_dict, &mx->factors, &mx->n_factors, + PV_NONE)) goto lossage; { - int i; + size_t i; - for (i = 0; i < n_factors; i++) + for (i = 0; i < mx->n_factors; i++) { - if (factors[i]->p.mxd.vartype != MXD_CONTINUOUS) + struct variable *v = mx->factors[i]; + struct mxd_var *mv = v->aux; + assert (mv != NULL); + if (mv->var_type != MXD_CONTINUOUS) { msg (SE, _("Factor variable %s is already another type."), tokid); goto lossage; } - factors[i]->p.mxd.vartype = MXD_FACTOR; - factors[i]->p.mxd.subtype = i; + var_clear_aux (v); + attach_mxd_aux (v, MXD_FACTOR, i); } } } @@ -386,38 +393,38 @@ cmd_matrix_data (void) { lex_match ('='); - if (cells != -1) + if (mx->cells != -1) { msg (SE, _("CELLS subcommand multiply specified.")); goto lossage; } - if (!lex_integer_p () || lex_integer () < 1) + if (!lex_is_integer () || lex_integer () < 1) { lex_error (_("expecting positive integer")); goto lossage; } - cells = lex_integer (); + mx->cells = lex_integer (); lex_get (); } else if (lex_match_id ("N")) { lex_match ('='); - if (pop_n != -1) + if (mx->pop_n != -1) { msg (SE, _("N subcommand multiply specified.")); goto lossage; } - if (!lex_integer_p () || lex_integer () < 1) + if (!lex_is_integer () || lex_integer () < 1) { lex_error (_("expecting positive integer")); goto lossage; } - pop_n = lex_integer (); + mx->pop_n = lex_integer (); lex_get (); } else if (lex_match_id ("CONTENTS")) @@ -439,7 +446,7 @@ cmd_matrix_data (void) int i; for (i = 0; i <= PROX; i++) - is_per_factor[i] = 0; + mx->is_per_factor[i] = 0; } for (;;) @@ -461,7 +468,7 @@ cmd_matrix_data (void) msg (SE, _("Mismatched right parenthesis (`(').")); goto lossage; } - if (contents[n_contents - 1] == LPAREN) + if (mx->contents[mx->n_contents - 1] == LPAREN) { msg (SE, _("Empty parentheses not allowed.")); goto lossage; @@ -498,9 +505,9 @@ cmd_matrix_data (void) collide |= (1 << collide_index); item = content_type; - is_per_factor[item] = inside_parens; + mx->is_per_factor[item] = inside_parens; } - contents[n_contents++] = item; + mx->contents[mx->n_contents++] = item; if (token == '/' || token == '.') break; @@ -511,7 +518,7 @@ cmd_matrix_data (void) msg (SE, _("Missing right parenthesis.")); goto lossage; } - contents[n_contents] = EOC; + mx->contents[mx->n_contents] = EOC; } else { @@ -532,17 +539,17 @@ cmd_matrix_data (void) goto lossage; } - if (!n_contents && !explicit_rowtype) + if (!mx->n_contents && !mx->explicit_rowtype) { msg (SW, _("CONTENTS subcommand not specified: assuming file " "contains only CORR matrix.")); - contents[0] = CORR; - contents[1] = EOC; - n_contents = 0; + mx->contents[0] = CORR; + mx->contents[1] = EOC; + mx->n_contents = 0; } - if (n_factors && !explicit_rowtype && cells == -1) + if (mx->n_factors && !mx->explicit_rowtype && mx->cells == -1) { msg (SE, _("Missing CELLS subcommand. CELLS is required " "when ROWTYPE_ is not given in the data and " @@ -550,7 +557,7 @@ cmd_matrix_data (void) goto lossage; } - if (explicit_rowtype && single_split) + if (mx->explicit_rowtype && mx->single_split) { msg (SE, _("Split file values must be present in the data when " "ROWTYPE_ is present.")); @@ -558,23 +565,19 @@ cmd_matrix_data (void) } /* Create VARNAME_. */ - { - varname_ = force_create_variable (&default_dict, "VARNAME_", - ALPHA, 8); - varname_->p.mxd.vartype = MXD_VARNAME; - varname_->p.mxd.subtype = 0; - } + mx->varname_ = dict_create_var_assert (default_dict, "VARNAME_", 8); + attach_mxd_aux (mx->varname_, MXD_VARNAME, 0); /* Sort the dictionary variables into the desired order for the system file output. */ { - int i; - - qsort (default_dict.var, default_dict.nvar, sizeof *default_dict.var, - compare_variables_by_mxd_vartype); + struct variable **v; + size_t nv; - for (i = 0; i < default_dict.nvar; i++) - default_dict.var[i]->index = i; + dict_get_vars (default_dict, &v, &nv, 0); + qsort (v, nv, sizeof *v, compare_variables_by_mxd_var_type); + dict_reorder_vars (default_dict, v, nv); + free (v); } /* Set formats. */ @@ -590,45 +593,48 @@ cmd_matrix_data (void) int i; - first_continuous = -1; - for (i = 0; i < default_dict.nvar; i++) + mx->first_continuous = -1; + for (i = 0; i < dict_get_var_cnt (default_dict); i++) { - struct variable *v = default_dict.var[i]; - int type = v->p.mxd.vartype; + struct variable *v = dict_get_var (default_dict, i); + struct mxd_var *mv = v->aux; + int type = mv->var_type; assert (type >= 0 && type < MXD_COUNT); v->print = v->write = fmt_tab[type]; if (type == MXD_CONTINUOUS) - n_continuous++; - if (first_continuous == -1 && type == MXD_CONTINUOUS) - first_continuous = i; + mx->n_continuous++; + if (mx->first_continuous == -1 && type == MXD_CONTINUOUS) + mx->first_continuous = i; } } - if (n_continuous == 0) + if (mx->n_continuous == 0) { msg (SE, _("No continuous variables specified.")); goto lossage; } -#if DEBUGGING - debug_print (); -#endif + mx->reader = dfm_open_reader (fh); + if (mx->reader == NULL) + goto lossage; - if (explicit_rowtype) - read_matrices_with_rowtype (); + if (mx->explicit_rowtype) + read_matrices_with_rowtype (mx); else - read_matrices_without_rowtype (); + read_matrices_without_rowtype (mx); + + dfm_close_reader (mx->reader); - pool_destroy (container); + pool_destroy (mx->container); return CMD_SUCCESS; lossage: discard_variables (); - free (factors); - pool_destroy (container); + free (mx->factors); + pool_destroy (mx->container); return CMD_FAILURE; } @@ -667,7 +673,7 @@ string_to_content_type (char *s, int *collide) }; for (tp = tab; tp->value != -1; tp++) - if (!strcmp (s, tp->string)) + if (!strcasecmp (s, tp->string)) { if (collide) *collide = tp->collide; @@ -677,203 +683,118 @@ string_to_content_type (char *s, int *collide) return -1; } -/* Compare two variables using p.mxd.vartype and p.mxd.subtype +/* Compare two variables using p.mxd.var_type and p.mxd.sub_type fields. */ static int -compare_variables_by_mxd_vartype (const void *a_, const void *b_) +compare_variables_by_mxd_var_type (const void *a_, const void *b_) { struct variable *const *pa = a_; struct variable *const *pb = b_; - const struct matrix_data_proc *a = &(*pa)->p.mxd; - const struct matrix_data_proc *b = &(*pb)->p.mxd; - - if (a->vartype != b->vartype) - return a->vartype > b->vartype ? 1 : -1; + const struct mxd_var *a = (*pa)->aux; + const struct mxd_var *b = (*pb)->aux; + + if (a->var_type != b->var_type) + return a->var_type > b->var_type ? 1 : -1; else - return a->subtype < b->subtype ? -1 : a->subtype > b->subtype; + return a->sub_type < b->sub_type ? -1 : a->sub_type > b->sub_type; } -#if DEBUGGING -/* Print out the command as input. */ +/* Attaches a struct mxd_var with the specific member values to + V. */ static void -debug_print (void) +attach_mxd_aux (struct variable *v, int var_type, int sub_type) { - printf ("MATRIX DATA\n\t/VARIABLES="); + struct mxd_var *mv; - { - int i; - - for (i = 0; i < default_dict.nvar; i++) - printf ("%s ", default_dict.var[i]->name); - } - printf ("\n"); - - printf ("\t/FORMAT="); - if (fmt == LIST) - printf ("LIST"); - else if (fmt == FREE) - printf ("FREE"); - else - assert (0); - if (section == LOWER) - printf (" LOWER"); - else if (section == UPPER) - printf (" UPPER"); - else if (section == FULL) - printf (" FULL"); - else - assert (0); - if (diag == DIAGONAL) - printf (" DIAGONAL\n"); - else if (diag == NODIAGONAL) - printf (" NODIAGONAL\n"); - else - assert (0); - - if (default_dict.n_splits) - { - int i; - - printf ("\t/SPLIT="); - for (i = 0; i < default_dict.n_splits; i++) - printf ("%s ", default_dict.splits[i]->name); - if (single_split) - printf ("\t/* single split"); - printf ("\n"); - } - - if (n_factors) - { - int i; - - printf ("\t/FACTORS="); - for (i = 0; i < n_factors; i++) - printf ("%s ", factors[i]->name); - printf ("\n"); - } - - if (cells != -1) - printf ("\t/CELLS=%d\n", cells); - - if (pop_n != -1) - printf ("\t/N=%d\n", pop_n); - - if (n_contents) - { - int i; - int space = 0; - - printf ("\t/CONTENTS="); - for (i = 0; i < n_contents; i++) - { - if (contents[i] == LPAREN) - { - if (space) - printf (" "); - printf ("("); - space = 0; - } - else if (contents[i] == RPAREN) - { - printf (")"); - space = 1; - } - else - { - - assert (contents[i] >= 0 && contents[i] <= PROX); - if (space) - printf (" "); - printf ("%s", content_names[contents[i]]); - space = 1; - } - } - printf ("\n"); - } + assert (v->aux == NULL); + mv = xmalloc (sizeof *mv); + mv->var_type = var_type; + mv->sub_type = sub_type; + var_attach_aux (v, mv, var_dtor_free); } -#endif /* DEBUGGING */ /* Matrix tokenizer. */ /* Matrix token types. */ -enum +enum matrix_token_type { - MNULL, /* No token. */ MNUM, /* Number. */ - MSTR, /* String. */ - MSTOP /* End of file. */ + MSTR /* String. */ }; -/* Current matrix token. */ -static int mtoken; - -/* Token string if applicable; not null-terminated. */ -static char *mtokstr; - -/* Length of mtokstr in characters. */ -static int mtoklen; - -/* Token value if applicable. */ -static double mtokval; +/* A MATRIX DATA parsing token. */ +struct matrix_token + { + enum matrix_token_type type; + double number; /* MNUM: token value. */ + char *string; /* MSTR: token string; not null-terminated. */ + int length; /* MSTR: tokstr length. */ + }; -static int mget_token (void); +static int mget_token (struct matrix_token *, struct dfm_reader *); #if DEBUGGING -#define mget_token() mget_token_dump() - -static int -mget_token_dump (void) -{ - int result = (mget_token) (); - mdump_token (); - return result; -} +#define mget_token(TOKEN, READER) mget_token_dump(TOKEN, READER) static void -mdump_token (void) +mdump_token (const struct matrix_token *token) { - switch (mtoken) + switch (token->type) { - case MNULL: - printf (" "); - break; case MNUM: - printf (" #%g", mtokval); + printf (" #%g", token->number); break; case MSTR: - printf (" #'%.*s'", mtoklen, mtokstr); - break; - case MSTOP: - printf (" "); + printf (" '%.*s'", token->length, token->string); break; default: assert (0); } fflush (stdout); } + +static int +mget_token_dump (struct matrix_token *token, struct dfm_reader *reader) +{ + int result = (mget_token) (token, reader); + mdump_token (token); + return result; +} #endif -/* Return the current position in the data file. */ +/* Return the current position in READER. */ static const char * -context (void) +context (struct dfm_reader *reader) { static char buf[32]; - int len; - char *p = dfm_get_record (data_file, &len); - - if (!p || !len) - strcpy (buf, "at end of line"); - else + + if (dfm_eof (reader)) + strcpy (buf, "at end of file"); + else { - char *cp = buf; - int n_copy = min (10, len); - cp = stpcpy (buf, "before `"); - while (n_copy && isspace ((unsigned char) *p)) - p++, n_copy++; - while (n_copy && !isspace ((unsigned char) *p)) - *cp++ = *p++, n_copy--; - *cp++ = '\''; - *cp = 0; + struct fixed_string line; + const char *sp; + + dfm_get_record (reader, &line); + sp = ls_c_str (&line); + while (sp < ls_end (&line) && isspace ((unsigned char) *sp)) + sp++; + if (sp >= ls_end (&line)) + strcpy (buf, "at end of line"); + else + { + char *dp; + size_t copy_cnt = 0; + + dp = stpcpy (buf, "before `"); + while (sp < ls_end (&line) && !isspace ((unsigned char) *sp) + && copy_cnt < 10) + { + *dp++ = *sp++; + copy_cnt++; + } + strcpy (dp, "'"); + } } return buf; @@ -881,78 +802,57 @@ context (void) /* Is there at least one token left in the data file? */ static int -another_token (void) +another_token (struct dfm_reader *reader) { - char *cp, *ep; - int len; - - if (mtoken == MSTOP) - return 0; - for (;;) { - cp = dfm_get_record (data_file, &len); - if (!cp) - return 0; + struct fixed_string line; + const char *cp; + + if (dfm_eof (reader)) + return 0; + dfm_get_record (reader, &line); - ep = cp + len; - while (isspace ((unsigned char) *cp) && cp < ep) + cp = ls_c_str (&line); + while (isspace ((unsigned char) *cp) && cp < ls_end (&line)) cp++; - if (cp < ep) - break; + if (cp < ls_end (&line)) + { + dfm_forward_columns (reader, cp - ls_c_str (&line)); + return 1; + } - dfm_fwd_record (data_file); + dfm_forward_record (reader); } - - dfm_set_record (data_file, cp); - - return 1; } -/* Parse a MATRIX DATA token from data_file into mtok*. */ +/* Parse a MATRIX DATA token from READER into TOKEN. */ static int -(mget_token) (void) +(mget_token) (struct matrix_token *token, struct dfm_reader *reader) { - char *cp, *ep; - int len; + struct fixed_string line; int first_column; - - for (;;) - { - cp = dfm_get_record (data_file, &len); - if (!cp) - { - if (mtoken == MSTOP) - return 0; - mtoken = MSTOP; - return 1; - } - - ep = cp + len; - while (isspace ((unsigned char) *cp) && cp < ep) - cp++; + char *cp; - if (cp < ep) - break; + if (!another_token (reader)) + return 0; - dfm_fwd_record (data_file); - } - - dfm_set_record (data_file, cp); - first_column = dfm_get_cur_col (data_file) + 1; + dfm_get_record (reader, &line); + first_column = dfm_column_start (reader); /* Three types of fields: quoted with ', quoted with ", unquoted. */ + cp = ls_c_str (&line); if (*cp == '\'' || *cp == '"') { int quote = *cp; - mtoken = MSTR; - mtokstr = ++cp; - while (cp < ep && *cp != quote) + token->type = MSTR; + token->string = ++cp; + while (cp < ls_end (&line) && *cp != quote) cp++; - mtoklen = cp - mtokstr; - if (cp < ep) + token->length = cp - token->string; + if (cp < ls_end (&line)) cp++; else msg (SW, _("Scope of string exceeds line.")); @@ -961,8 +861,9 @@ static int { int is_num = isdigit ((unsigned char) *cp) || *cp == '.'; - mtokstr = cp++; - while (cp < ep && !isspace ((unsigned char) *cp) && *cp != ',' + token->string = cp++; + while (cp < ls_end (&line) + && !isspace ((unsigned char) *cp) && *cp != ',' && *cp != '-' && *cp != '+') { if (isdigit ((unsigned char) *cp)) @@ -976,141 +877,141 @@ static int cp++; } - mtoklen = cp - mtokstr; - assert (mtoklen); + token->length = cp - token->string; + assert (token->length); if (is_num) { struct data_in di; - di.s = mtokstr; - di.e = mtokstr + mtoklen; - di.v = (union value *) &mtokval; + di.s = token->string; + di.e = token->string + token->length; + di.v = (union value *) &token->number; di.f1 = first_column; - di.format.type = FMT_F; - di.format.w = mtoklen; - di.format.d = 0; + di.format = make_output_format (FMT_F, token->length, 0); if (!data_in (&di)) return 0; } else - mtoken = MSTR; + token->type = MSTR; } - dfm_set_record (data_file, cp); + dfm_forward_columns (reader, cp - ls_c_str (&line)); return 1; } /* Forcibly skip the end of a line for content type CONTENT in - data_file. */ + READER. */ static int -force_eol (const char *content) +force_eol (struct dfm_reader *reader, const char *content) { - char *cp; - int len; - - if (fmt == FREE) - return 1; + struct fixed_string line; + const char *cp; - cp = dfm_get_record (data_file, &len); - if (!cp) + if (dfm_eof (reader)) return 0; - while (len && isspace (*cp)) - cp++, len--; + dfm_get_record (reader, &line); + + cp = ls_c_str (&line); + while (isspace ((unsigned char) *cp) && cp < ls_end (&line)) + cp++; - if (len) + if (cp < ls_end (&line)) { msg (SE, _("End of line expected %s while reading %s."), - context (), content); + context (reader), content); return 0; } - dfm_fwd_record (data_file); - + dfm_forward_record (reader); return 1; } /* Back end, omitting ROWTYPE_. */ -/* MATRIX DATA data. */ -static double ***nr_data; - -/* Factor values. */ -static double *nr_factor_values; - -/* Largest-numbered cell that we have read in thus far, plus one. */ -static int max_cell_index; - -/* SPLIT FILE variable values. */ -static double *split_values; +struct nr_aux_data + { + struct matrix_data_pgm *mx; /* MATRIX DATA program. */ + double ***data; /* MATRIX DATA data. */ + double *factor_values; /* Factor values. */ + int max_cell_idx; /* Max-numbered cell that we have + read so far, plus one. */ + double *split_values; /* SPLIT FILE variable values. */ + }; -static int nr_read_splits (int compare); -static int nr_read_factors (int cell); -static void nr_output_data (void); -static int matrix_data_read_without_rowtype (void); +static int nr_read_splits (struct nr_aux_data *, int compare); +static int nr_read_factors (struct nr_aux_data *, int cell); +static void nr_output_data (struct nr_aux_data *, struct ccase *, + write_case_func *, write_case_data); +static void matrix_data_read_without_rowtype (struct case_source *source, + struct ccase *, + write_case_func *, + write_case_data); /* Read from the data file and write it to the active file. */ static void -read_matrices_without_rowtype (void) +read_matrices_without_rowtype (struct matrix_data_pgm *mx) { - if (cells == -1) - cells = 1; + struct nr_aux_data nr; - mtoken = MNULL; - split_values = xmalloc (sizeof *split_values * default_dict.n_splits); - nr_factor_values = xmalloc (sizeof *nr_factor_values * n_factors * cells); - max_cell_index = 0; - - matrix_data_source.read = (void (*)(void)) matrix_data_read_without_rowtype; - vfm_source = &matrix_data_source; + if (mx->cells == -1) + mx->cells = 1; + + nr.mx = mx; + nr.data = NULL; + nr.factor_values = xnmalloc (mx->n_factors * mx->cells, + sizeof *nr.factor_values); + nr.max_cell_idx = 0; + nr.split_values = xnmalloc (dict_get_split_cnt (default_dict), + sizeof *nr.split_values); + + vfm_source = create_case_source (&matrix_data_without_rowtype_source_class, &nr); - procedure (NULL, NULL, NULL); + procedure (NULL, NULL); - free (split_values); - free (nr_factor_values); - - fh_close_handle (data_file); + free (nr.split_values); + free (nr.factor_values); } /* Mirror data across the diagonal of matrix CP which contains CONTENT type data. */ static void -fill_matrix (int content, double *cp) +fill_matrix (struct matrix_data_pgm *mx, int content, double *cp) { int type = content_type[content]; - if (type == 1 && section != FULL) + if (type == 1 && mx->section != FULL) { - if (diag == NODIAGONAL) + if (mx->diag == NODIAGONAL) { const double fill = content == CORR ? 1.0 : SYSMIS; int i; - for (i = 0; i < n_continuous; i++) - cp[i * (1 + n_continuous)] = fill; + for (i = 0; i < mx->n_continuous; i++) + cp[i * (1 + mx->n_continuous)] = fill; } { int c, r; - if (section == LOWER) + if (mx->section == LOWER) { - int n_lines = n_continuous; - if (section != FULL && diag == NODIAGONAL) + int n_lines = mx->n_continuous; + if (mx->section != FULL && mx->diag == NODIAGONAL) n_lines--; for (r = 1; r < n_lines; r++) for (c = 0; c < r; c++) - cp[r + c * n_continuous] = cp[c + r * n_continuous]; + cp[r + c * mx->n_continuous] = cp[c + r * mx->n_continuous]; } else { - assert (section == UPPER); - for (r = 1; r < n_continuous; r++) + assert (mx->section == UPPER); + for (r = 1; r < mx->n_continuous; r++) for (c = 0; c < r; c++) - cp[c + r * n_continuous] = cp[r + c * n_continuous]; + cp[c + r * mx->n_continuous] = cp[r + c * mx->n_continuous]; } } } @@ -1118,78 +1019,73 @@ fill_matrix (int content, double *cp) { int c; - for (c = 1; c < n_continuous; c++) + for (c = 1; c < mx->n_continuous; c++) cp[c] = cp[0]; } } -/* Read data lines for content type CONTENT from the data file. If - PER_FACTOR is nonzero, then factor information is read from the - data file. Data is for cell number CELL. */ +/* Read data lines for content type CONTENT from the data file. + If PER_FACTOR is nonzero, then factor information is read from + the data file. Data is for cell number CELL. */ static int -nr_read_data_lines (int per_factor, int cell, int content, int compare) +nr_read_data_lines (struct nr_aux_data *nr, + int per_factor, int cell, int content, int compare) { - /* Content type. */ - const int type = content_type[content]; - - /* Number of lines that must be parsed from the data file for this - content type. */ - int n_lines; - - /* Current position in vector or matrix. */ - double *cp; - - /* Counter. */ + struct matrix_data_pgm *mx = nr->mx; + const int type = content_type[content]; /* Content type. */ + int n_lines; /* Number of lines to parse from data file for this type. */ + double *cp; /* Current position in vector or matrix. */ int i; if (type != 1) n_lines = 1; else { - n_lines = n_continuous; - if (section != FULL && diag == NODIAGONAL) + n_lines = mx->n_continuous; + if (mx->section != FULL && mx->diag == NODIAGONAL) n_lines--; } - cp = nr_data[content][cell]; - if (type == 1 && section == LOWER && diag == NODIAGONAL) - cp += n_continuous; + cp = nr->data[content][cell]; + if (type == 1 && mx->section == LOWER && mx->diag == NODIAGONAL) + cp += mx->n_continuous; for (i = 0; i < n_lines; i++) { int n_cols; - if (!nr_read_splits (1)) + if (!nr_read_splits (nr, 1)) return 0; - if (per_factor && !nr_read_factors (cell)) + if (per_factor && !nr_read_factors (nr, cell)) return 0; compare = 1; switch (type) { case 0: - n_cols = n_continuous; + n_cols = mx->n_continuous; break; case 1: - switch (section) + switch (mx->section) { case LOWER: n_cols = i + 1; break; case UPPER: cp += i; - n_cols = n_continuous - i; - if (diag == NODIAGONAL) + n_cols = mx->n_continuous - i; + if (mx->diag == NODIAGONAL) { n_cols--; cp++; } break; case FULL: - n_cols = n_continuous; + n_cols = mx->n_continuous; break; default: assert (0); + abort (); } break; case 2: @@ -1197,6 +1093,7 @@ nr_read_data_lines (int per_factor, int cell, int content, int compare) break; default: assert (0); + abort (); } { @@ -1204,68 +1101,77 @@ nr_read_data_lines (int per_factor, int cell, int content, int compare) for (j = 0; j < n_cols; j++) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) return 0; - if (mtoken != MNUM) + if (token.type != MNUM) { msg (SE, _("expecting value for %s %s"), - default_dict.var[j]->name, context ()); + dict_get_var (default_dict, j)->name, + context (mx->reader)); return 0; } - *cp++ = mtokval; + *cp++ = token.number; } - if (!force_eol (content_names[content])) + if (mx->fmt != FREE + && !force_eol (mx->reader, content_names[content])) return 0; debug_printf (("\n")); } - if (section == LOWER) - cp += n_continuous - n_cols; + if (mx->section == LOWER) + cp += mx->n_continuous - n_cols; } - fill_matrix (content, nr_data[content][cell]); + fill_matrix (mx, content, nr->data[content][cell]); return 1; } /* When ROWTYPE_ does not appear in the data, reads the matrices and writes them to the output file. Returns success. */ -static int -matrix_data_read_without_rowtype (void) +static void +matrix_data_read_without_rowtype (struct case_source *source, + struct ccase *c, + write_case_func *write_case, + write_case_data wc_data) { + struct nr_aux_data *nr = source->aux; + struct matrix_data_pgm *mx = nr->mx; + { int *cp; - nr_data = pool_alloc (container, (PROX + 1) * sizeof *nr_data); + nr->data = pool_nalloc (mx->container, PROX + 1, sizeof *nr->data); { int i; for (i = 0; i <= PROX; i++) - nr_data[i] = NULL; + nr->data[i] = NULL; } - for (cp = contents; *cp != EOC; cp++) + for (cp = mx->contents; *cp != EOC; cp++) if (*cp != LPAREN && *cp != RPAREN) { - int per_factor = is_per_factor[*cp]; + int per_factor = mx->is_per_factor[*cp]; int n_entries; - n_entries = n_continuous; + n_entries = mx->n_continuous; if (content_type[*cp] == 1) - n_entries *= n_continuous; + n_entries *= mx->n_continuous; { - int n_vectors = per_factor ? cells : 1; + int n_vectors = per_factor ? mx->cells : 1; int i; - nr_data[*cp] = pool_alloc (container, - n_vectors * sizeof **nr_data); + nr->data[*cp] = pool_nalloc (mx->container, + n_vectors, sizeof **nr->data); for (i = 0; i < n_vectors; i++) - nr_data[*cp][i] = pool_alloc (container, - n_entries * sizeof ***nr_data); + nr->data[*cp][i] = pool_nalloc (mx->container, + n_entries, sizeof ***nr->data); } } } @@ -1274,10 +1180,10 @@ matrix_data_read_without_rowtype (void) { int *bp, *ep, *np; - if (!nr_read_splits (0)) - return 0; + if (!nr_read_splits (nr, 0)) + return; - for (bp = contents; *bp != EOC; bp = np) + for (bp = mx->contents; *bp != EOC; bp = np) { int per_factor; @@ -1304,21 +1210,22 @@ matrix_data_read_without_rowtype (void) { int i; - for (i = 0; i < (per_factor ? cells : 1); i++) + for (i = 0; i < (per_factor ? mx->cells : 1); i++) { int *cp; for (cp = bp; cp < ep; cp++) - if (!nr_read_data_lines (per_factor, i, *cp, cp != bp)) - return 0; + if (!nr_read_data_lines (nr, per_factor, i, *cp, cp != bp)) + return; } } } - nr_output_data (); + nr_output_data (nr, c, write_case, wc_data); - if (default_dict.n_splits == 0 || !another_token ()) - return 1; + if (dict_get_split_cnt (default_dict) == 0 + || !another_token (mx->reader)) + return; } } @@ -1326,9 +1233,12 @@ matrix_data_read_without_rowtype (void) values read to the last values read and returns 1 if they're equal, 0 otherwise. */ static int -nr_read_splits (int compare) +nr_read_splits (struct nr_aux_data *nr, int compare) { - static int just_read = 0; + struct matrix_data_pgm *mx = nr->mx; + static int just_read = 0; /* FIXME: WTF? */ + size_t split_cnt; + size_t i; if (compare && just_read) { @@ -1336,43 +1246,45 @@ nr_read_splits (int compare) return 1; } - if (default_dict.n_splits == 0) + if (dict_get_split_vars (default_dict) == NULL) return 1; - if (single_split) + if (mx->single_split) { - if (!compare) - split_values[0] = ++default_dict.splits[0]->p.mxd.subtype; + if (!compare) + { + struct mxd_var *mv = dict_get_split_vars (default_dict)[0]->aux; + nr->split_values[0] = ++mv->sub_type; + } return 1; } if (!compare) just_read = 1; - - { - int i; - - for (i = 0; i < default_dict.n_splits; i++) - { - if (!mget_token ()) - return 0; - if (mtoken != MNUM) - { - msg (SE, _("Syntax error expecting SPLIT FILE value %s."), - context ()); - return 0; - } - if (!compare) - split_values[i] = mtokval; - else if (split_values[i] != mtokval) - { - msg (SE, _("Expecting value %g for %s."), - split_values[i], default_dict.splits[i]->name); - return 0; - } - } - } + split_cnt = dict_get_split_cnt (default_dict); + for (i = 0; i < split_cnt; i++) + { + struct matrix_token token; + if (!mget_token (&token, mx->reader)) + return 0; + if (token.type != MNUM) + { + msg (SE, _("Syntax error expecting SPLIT FILE value %s."), + context (mx->reader)); + return 0; + } + + if (!compare) + nr->split_values[i] = token.number; + else if (nr->split_values[i] != token.number) + { + msg (SE, _("Expecting value %g for %s."), + nr->split_values[i], + dict_get_split_vars (default_dict)[i]->name); + return 0; + } + } return 1; } @@ -1381,43 +1293,45 @@ nr_read_splits (int compare) values read to the last values read and returns 1 if they're equal, 0 otherwise. */ static int -nr_read_factors (int cell) +nr_read_factors (struct nr_aux_data *nr, int cell) { + struct matrix_data_pgm *mx = nr->mx; int compare; - if (n_factors == 0) + if (mx->n_factors == 0) return 1; - assert (max_cell_index >= cell); - if (cell != max_cell_index) + assert (nr->max_cell_idx >= cell); + if (cell != nr->max_cell_idx) compare = 1; else { compare = 0; - max_cell_index++; + nr->max_cell_idx++; } { - int i; + size_t i; - for (i = 0; i < n_factors; i++) + for (i = 0; i < mx->n_factors; i++) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) return 0; - if (mtoken != MNUM) + if (token.type != MNUM) { msg (SE, _("Syntax error expecting factor value %s."), - context ()); + context (mx->reader)); return 0; } if (!compare) - nr_factor_values[i + n_factors * cell] = mtokval; - else if (nr_factor_values[i + n_factors * cell] != mtokval) + nr->factor_values[i + mx->n_factors * cell] = token.number; + else if (nr->factor_values[i + mx->n_factors * cell] != token.number) { msg (SE, _("Syntax error expecting value %g for %s %s."), - nr_factor_values[i + n_factors * cell], - factors[i]->name, context ()); + nr->factor_values[i + mx->n_factors * cell], + mx->factors[i]->name, context (mx->reader)); return 0; } } @@ -1429,70 +1343,75 @@ nr_read_factors (int cell) /* Write the contents of a cell having content type CONTENT and data CP to the active file. */ static void -dump_cell_content (int content, double *cp) +dump_cell_content (struct matrix_data_pgm *mx, int content, double *cp, + struct ccase *c, + write_case_func *write_case, write_case_data wc_data) { int type = content_type[content]; { - st_bare_pad_copy (temp_case->data[rowtype_->fv].s, - content_names[content], 8); + buf_copy_str_rpad (case_data_rw (c, mx->rowtype_->fv)->s, 8, + content_names[content]); if (type != 1) - memset (&temp_case->data[varname_->fv].s, ' ', 8); + memset (case_data_rw (c, mx->varname_->fv)->s, ' ', 8); } { - int n_lines = (type == 1) ? n_continuous : 1; + int n_lines = (type == 1) ? mx->n_continuous : 1; int i; for (i = 0; i < n_lines; i++) { int j; - for (j = 0; j < n_continuous; j++) + for (j = 0; j < mx->n_continuous; j++) { - temp_case->data[(default_dict.var - [first_continuous + j]->fv)].f = *cp; - debug_printf (("c:%s(%g) ", - default_dict.var[first_continuous + j]->name, - *cp)); + int fv = dict_get_var (default_dict, mx->first_continuous + j)->fv; + case_data_rw (c, fv)->f = *cp; cp++; } if (type == 1) - st_bare_pad_copy (temp_case->data[varname_->fv].s, - default_dict.var[first_continuous + i]->name, - 8); - debug_printf (("\n")); - write_case (); + buf_copy_str_rpad (case_data_rw (c, mx->varname_->fv)->s, 8, + dict_get_var (default_dict, + mx->first_continuous + i)->name); + write_case (wc_data); } } } /* Finally dump out everything from nr_data[] to the output file. */ static void -nr_output_data (void) +nr_output_data (struct nr_aux_data *nr, struct ccase *c, + write_case_func *write_case, write_case_data wc_data) { + struct matrix_data_pgm *mx = nr->mx; + { - int i; - - for (i = 0; i < default_dict.n_splits; i++) - temp_case->data[default_dict.splits[i]->fv].f = split_values[i]; + struct variable *const *split; + size_t split_cnt; + size_t i; + + split_cnt = dict_get_split_cnt (default_dict); + split = dict_get_split_vars (default_dict); + for (i = 0; i < split_cnt; i++) + case_data_rw (c, split[i]->fv)->f = nr->split_values[i]; } - if (n_factors) + if (mx->n_factors) { int cell; - for (cell = 0; cell < cells; cell++) + for (cell = 0; cell < mx->cells; cell++) { { - int factor; + size_t factor; - for (factor = 0; factor < n_factors; factor++) + for (factor = 0; factor < mx->n_factors; factor++) { - temp_case->data[factors[factor]->fv].f - = nr_factor_values[factor + cell * n_factors]; - debug_printf (("f:%s ", factors[factor]->name)); + case_data_rw (c, mx->factors[factor]->fv)->f + = nr->factor_values[factor + cell * mx->n_factors]; + debug_printf (("f:%s ", mx->factors[factor]->name)); } } @@ -1500,12 +1419,13 @@ nr_output_data (void) int content; for (content = 0; content <= PROX; content++) - if (is_per_factor[content]) + if (mx->is_per_factor[content]) { - assert (nr_data[content] != NULL - && nr_data[content][cell] != NULL); + assert (nr->data[content] != NULL + && nr->data[content][cell] != NULL); - dump_cell_content (content, nr_data[content][cell]); + dump_cell_content (mx, content, nr->data[content][cell], + c, write_case, wc_data); } } } @@ -1515,23 +1435,21 @@ nr_output_data (void) int content; { - int factor; + size_t factor; - for (factor = 0; factor < n_factors; factor++) - temp_case->data[factors[factor]->fv].f = SYSMIS; + for (factor = 0; factor < mx->n_factors; factor++) + case_data_rw (c, mx->factors[factor]->fv)->f = SYSMIS; } for (content = 0; content <= PROX; content++) - if (!is_per_factor[content] && nr_data[content] != NULL) - dump_cell_content (content, nr_data[content][0]); + if (!mx->is_per_factor[content] && nr->data[content] != NULL) + dump_cell_content (mx, content, nr->data[content][0], + c, write_case, wc_data); } } /* Back end, with ROWTYPE_. */ -/* Type of current row. */ -static int wr_content; - /* All the data for one set of factor values. */ struct factor_data { @@ -1541,160 +1459,202 @@ struct factor_data struct factor_data *next; }; -/* All the data, period. */ -struct factor_data *wr_data; - -/* Current factor. */ -struct factor_data *wr_current; +/* With ROWTYPE_ auxiliary data. */ +struct wr_aux_data + { + struct matrix_data_pgm *mx; /* MATRIX DATA program. */ + int content; /* Type of current row. */ + double *split_values; /* SPLIT FILE variable values. */ + struct factor_data *data; /* All the data. */ + struct factor_data *current; /* Current factor. */ + }; -static int wr_read_splits (void); -static int wr_output_data (void); -static int wr_read_rowtype (void); -static int wr_read_factors (void); -static int wr_read_indeps (void); -static int matrix_data_read_with_rowtype (void); +static int wr_read_splits (struct wr_aux_data *, struct ccase *, + write_case_func *, write_case_data); +static int wr_output_data (struct wr_aux_data *, struct ccase *, + write_case_func *, write_case_data); +static int wr_read_rowtype (struct wr_aux_data *, + const struct matrix_token *, struct dfm_reader *); +static int wr_read_factors (struct wr_aux_data *); +static int wr_read_indeps (struct wr_aux_data *); +static void matrix_data_read_with_rowtype (struct case_source *, + struct ccase *, + write_case_func *, + write_case_data); /* When ROWTYPE_ appears in the data, reads the matrices and writes them to the output file. */ static void -read_matrices_with_rowtype (void) +read_matrices_with_rowtype (struct matrix_data_pgm *mx) { - mtoken = MNULL; - wr_data = wr_current = NULL; - split_values = NULL; - cells = 0; + struct wr_aux_data wr; - matrix_data_source.read = (void (*)(void)) matrix_data_read_with_rowtype; - vfm_source = &matrix_data_source; - - procedure (NULL, NULL, NULL); + wr.mx = mx; + wr.content = -1; + wr.split_values = NULL; + wr.data = NULL; + wr.current = NULL; + mx->cells = 0; + + vfm_source = create_case_source (&matrix_data_with_rowtype_source_class, + &wr); + procedure (NULL, NULL); - free (split_values); - fh_close_handle (data_file); + free (wr.split_values); } /* Read from the data file and write it to the active file. */ -static int -matrix_data_read_with_rowtype (void) +static void +matrix_data_read_with_rowtype (struct case_source *source, + struct ccase *c, + write_case_func *write_case, + write_case_data wc_data) { + struct wr_aux_data *wr = source->aux; + struct matrix_data_pgm *mx = wr->mx; + do { - if (!wr_read_splits ()) - return 0; + if (!wr_read_splits (wr, c, write_case, wc_data)) + return; - if (!wr_read_factors ()) - return 0; + if (!wr_read_factors (wr)) + return; - if (!wr_read_indeps ()) - return 0; + if (!wr_read_indeps (wr)) + return; } - while (another_token ()); + while (another_token (mx->reader)); - wr_output_data (); - return 1; + wr_output_data (wr, c, write_case, wc_data); } /* Read the split file variables. If they differ from the previous set of split variables then output the data. Returns success. */ static int -wr_read_splits (void) +wr_read_splits (struct wr_aux_data *wr, + struct ccase *c, + write_case_func *write_case, write_case_data wc_data) { + struct matrix_data_pgm *mx = wr->mx; int compare; - - if (default_dict.n_splits == 0) + size_t split_cnt; + + split_cnt = dict_get_split_cnt (default_dict); + if (split_cnt == 0) return 1; - if (split_values) + if (wr->split_values) compare = 1; else { compare = 0; - split_values = xmalloc (sizeof *split_values * default_dict.n_splits); + wr->split_values = xnmalloc (split_cnt, sizeof *wr->split_values); } { int different = 0; int i; - - for (i = 0; i < default_dict.n_splits; i++) + + for (i = 0; i < split_cnt; i++) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) return 0; - if (mtoken != MNUM) + if (token.type != MNUM) { msg (SE, _("Syntax error %s expecting SPLIT FILE value."), - context ()); + context (mx->reader)); return 0; } - if (compare && split_values[i] != mtokval && !different) + if (compare && wr->split_values[i] != token.number && !different) { - if (!wr_output_data ()) + if (!wr_output_data (wr, c, write_case, wc_data)) return 0; different = 1; - cells = 0; + mx->cells = 0; } - split_values[i] = mtokval; + wr->split_values[i] = token.number; } } return 1; } -/* Return strcmp()-type comparison of the n_factors factors at _A and - _B. Sort missing values toward the end. */ +/* Compares doubles A and B, treating SYSMIS as greatest. */ static int -compare_factors (const void *pa, const void *pb) +compare_doubles (const void *a_, const void *b_, void *aux UNUSED) { - const double *a = (*(struct factor_data **) pa)->factors; - const double *b = (*(struct factor_data **) pb)->factors; - int i; + const double *a = a_; + const double *b = b_; - for (i = 0; i < n_factors; i++, a++, b++) - { - if (*a == *b) - continue; - - if (*a == SYSMIS) - return 1; - else if (*b == SYSMIS) - return -1; - else - return *a - *b < 0 ? -1 : 1; - } + if (*a == *b) + return 0; + else if (*a == SYSMIS) + return 1; + else if (*b == SYSMIS) + return -1; + else if (*a > *b) + return 1; + else + return -1; +} - return 0; +/* Return strcmp()-type comparison of the MX->n_factors factors at _A and + _B. Sort missing values toward the end. */ +static int +compare_factors (const void *a_, const void *b_, void *mx_) +{ + struct matrix_data_pgm *mx = mx_; + struct factor_data *const *pa = a_; + struct factor_data *const *pb = b_; + const double *a = (*pa)->factors; + const double *b = (*pb)->factors; + + return lexicographical_compare_3way (a, mx->n_factors, + b, mx->n_factors, + sizeof *a, + compare_doubles, NULL); } /* Write out the data for the current split file to the active file. */ static int -wr_output_data (void) +wr_output_data (struct wr_aux_data *wr, + struct ccase *c, + write_case_func *write_case, write_case_data wc_data) { - { - int i; + struct matrix_data_pgm *mx = wr->mx; - for (i = 0; i < default_dict.n_splits; i++) - temp_case->data[default_dict.splits[i]->fv].f = split_values[i]; + { + struct variable *const *split; + size_t split_cnt; + size_t i; + + split_cnt = dict_get_split_cnt (default_dict); + split = dict_get_split_vars (default_dict); + for (i = 0; i < split_cnt; i++) + case_data_rw (c, split[i]->fv)->f = wr->split_values[i]; } - /* Sort the wr_data list. */ + /* Sort the wr->data list. */ { struct factor_data **factors; struct factor_data *iter; int i; - factors = xmalloc (sizeof *factors * cells); + factors = xnmalloc (mx->cells, sizeof *factors); - for (i = 0, iter = wr_data; iter; iter = iter->next, i++) + for (i = 0, iter = wr->data; iter; iter = iter->next, i++) factors[i] = iter; - qsort (factors, cells, sizeof *factors, compare_factors); + sort (factors, mx->cells, sizeof *factors, compare_factors, mx); - wr_data = factors[0]; - for (i = 0; i < cells - 1; i++) + wr->data = factors[0]; + for (i = 0; i < mx->cells - 1; i++) factors[i]->next = factors[i + 1]; - factors[cells - 1]->next = NULL; + factors[mx->cells - 1]->next = NULL; free (factors); } @@ -1703,17 +1663,14 @@ wr_output_data (void) { struct factor_data *iter; - for (iter = wr_data; iter; iter = iter->next) + for (iter = wr->data; iter; iter = iter->next) { { - int factor; + size_t factor; - for (factor = 0; factor < n_factors; factor++) - { - temp_case->data[factors[factor]->fv].f - = iter->factors[factor]; - debug_printf (("f:%s ", factors[factor]->name)); - } + for (factor = 0; factor < mx->n_factors; factor++) + case_data_rw (c, mx->factors[factor]->fv)->f + = iter->factors[factor]; } { @@ -1727,8 +1684,8 @@ wr_output_data (void) { int type = content_type[content]; int n_lines = (type == 1 - ? (n_continuous - - (section != FULL && diag == NODIAGONAL)) + ? (mx->n_continuous + - (mx->section != FULL && mx->diag == NODIAGONAL)) : 1); if (n_lines != iter->n_rows[content]) @@ -1742,34 +1699,39 @@ wr_output_data (void) } } - fill_matrix (content, iter->data[content]); + fill_matrix (mx, content, iter->data[content]); - dump_cell_content (content, iter->data[content]); + dump_cell_content (mx, content, iter->data[content], + c, write_case, wc_data); } } } } - pool_destroy (container); - container = pool_create (); + pool_destroy (mx->container); + mx->container = pool_create (); - wr_data = wr_current = NULL; + wr->data = wr->current = NULL; return 1; } -/* Read ROWTYPE_ from the data file. Return success. */ +/* Sets ROWTYPE_ based on the given TOKEN read from READER. + Return success. */ static int -wr_read_rowtype (void) +wr_read_rowtype (struct wr_aux_data *wr, + const struct matrix_token *token, + struct dfm_reader *reader) { - if (wr_content != -1) + if (wr->content != -1) { - msg (SE, _("Multiply specified ROWTYPE_ %s."), context ()); + msg (SE, _("Multiply specified ROWTYPE_ %s."), context (reader)); return 0; } - if (mtoken != MSTR) + if (token->type != MSTR) { - msg (SE, _("Syntax error %s expecting ROWTYPE_ string."), context ()); + msg (SE, _("Syntax error %s expecting ROWTYPE_ string."), + context (reader)); return 0; } @@ -1777,18 +1739,18 @@ wr_read_rowtype (void) char s[16]; char *cp; - memcpy (s, mtokstr, min (15, mtoklen)); - s[min (15, mtoklen)] = 0; + memcpy (s, token->string, min (15, token->length)); + s[min (15, token->length)] = 0; for (cp = s; *cp; cp++) *cp = toupper ((unsigned char) *cp); - wr_content = string_to_content_type (s, NULL); + wr->content = string_to_content_type (s, NULL); } - if (wr_content == -1) + if (wr->content == -1) { - msg (SE, _("Syntax error %s."), context ()); + msg (SE, _("Syntax error %s."), context (reader)); return 0; } @@ -1798,51 +1760,54 @@ wr_read_rowtype (void) /* Read the factors for the current row. Select a set of factors and point wr_current to it. */ static int -wr_read_factors (void) +wr_read_factors (struct wr_aux_data *wr) { - double *factor_values = local_alloc (sizeof *factor_values * n_factors); + struct matrix_data_pgm *mx = wr->mx; + double *factor_values = local_alloc (sizeof *factor_values * mx->n_factors); - wr_content = -1; + wr->content = -1; { - int i; + size_t i; - for (i = 0; i < n_factors; i++) + for (i = 0; i < mx->n_factors; i++) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) goto lossage; - if (mtoken == MSTR) + if (token.type == MSTR) { - if (!wr_read_rowtype ()) + if (!wr_read_rowtype (wr, &token, mx->reader)) goto lossage; - if (!mget_token ()) + if (!mget_token (&token, mx->reader)) goto lossage; } - if (mtoken != MNUM) + if (token.type != MNUM) { msg (SE, _("Syntax error expecting factor value %s."), - context ()); + context (mx->reader)); goto lossage; } - factor_values[i] = mtokval; + factor_values[i] = token.number; } } - if (wr_content == -1) + if (wr->content == -1) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) goto lossage; - if (!wr_read_rowtype ()) + if (!wr_read_rowtype (wr, &token, mx->reader)) goto lossage; } /* Try the most recent factor first as a simple caching mechanism. */ - if (wr_current) + if (wr->current) { - int i; + size_t i; - for (i = 0; i < n_factors; i++) - if (factor_values[i] != wr_current->factors[i]) + for (i = 0; i < mx->n_factors; i++) + if (factor_values[i] != wr->current->factors[i]) goto cache_miss; goto winnage; } @@ -1852,15 +1817,15 @@ cache_miss: { struct factor_data *iter; - for (iter = wr_data; iter; iter = iter->next) + for (iter = wr->data; iter; iter = iter->next) { - int i; + size_t i; - for (i = 0; i < n_factors; i++) + for (i = 0; i < mx->n_factors; i++) if (factor_values[i] != iter->factors[i]) goto next_item; - wr_current = iter; + wr->current = iter; goto winnage; next_item: ; @@ -1869,14 +1834,15 @@ cache_miss: /* Not found. Make a new item. */ { - struct factor_data *new = pool_alloc (container, sizeof *new); + struct factor_data *new = pool_alloc (mx->container, sizeof *new); - new->factors = pool_alloc (container, sizeof *new->factors * n_factors); + new->factors = pool_nalloc (mx->container, + mx->n_factors, sizeof *new->factors); { - int i; + size_t i; - for (i = 0; i < n_factors; i++) + for (i = 0; i < mx->n_factors; i++) new->factors[i] = factor_values[i]; } @@ -1890,9 +1856,9 @@ cache_miss: } } - new->next = wr_data; - wr_data = wr_current = new; - cells++; + new->next = wr->data; + wr->data = wr->current = new; + mx->cells++; } winnage: @@ -1904,28 +1870,29 @@ lossage: return 0; } -/* Read the independent variables into wr_current. */ +/* Read the independent variables into wr->current. */ static int -wr_read_indeps (void) +wr_read_indeps (struct wr_aux_data *wr) { - struct factor_data *c = wr_current; - const int type = content_type[wr_content]; - const int n_rows = c->n_rows[wr_content]; + struct matrix_data_pgm *mx = wr->mx; + struct factor_data *c = wr->current; + const int type = content_type[wr->content]; + const int n_rows = c->n_rows[wr->content]; double *cp; int n_cols; /* Allocate room for data if necessary. */ - if (c->data[wr_content] == NULL) + if (c->data[wr->content] == NULL) { - int n_items = n_continuous; + int n_items = mx->n_continuous; if (type == 1) - n_items *= n_continuous; + n_items *= mx->n_continuous; - c->data[wr_content] = pool_alloc (container, - sizeof **c->data * n_items); + c->data[wr->content] = pool_nalloc (mx->container, + n_items, sizeof **c->data); } - cp = &c->data[wr_content][n_rows * n_continuous]; + cp = &c->data[wr->content][n_rows * mx->n_continuous]; /* Figure out how much to read from this line. */ switch (type) @@ -1935,49 +1902,51 @@ wr_read_indeps (void) if (n_rows > 0) { msg (SE, _("Duplicate specification for %s."), - content_names[wr_content]); + content_names[wr->content]); return 0; } if (type == 0) - n_cols = n_continuous; + n_cols = mx->n_continuous; else n_cols = 1; break; case 1: - if (n_rows >= n_continuous - (section != FULL && diag == NODIAGONAL)) + if (n_rows >= mx->n_continuous - (mx->section != FULL && mx->diag == NODIAGONAL)) { msg (SE, _("Too many rows of matrix data for %s."), - content_names[wr_content]); + content_names[wr->content]); return 0; } - switch (section) + switch (mx->section) { case LOWER: n_cols = n_rows + 1; - if (diag == NODIAGONAL) - cp += n_continuous; + if (mx->diag == NODIAGONAL) + cp += mx->n_continuous; break; case UPPER: cp += n_rows; - n_cols = n_continuous - n_rows; - if (diag == NODIAGONAL) + n_cols = mx->n_continuous - n_rows; + if (mx->diag == NODIAGONAL) { n_cols--; cp++; } break; case FULL: - n_cols = n_continuous; + n_cols = mx->n_continuous; break; default: assert (0); + abort (); } break; default: assert (0); + abort (); } - c->n_rows[wr_content]++; + c->n_rows[wr->content]++; debug_printf ((" (c=%p,r=%d,n=%d)", c, n_rows + 1, n_cols)); @@ -1987,18 +1956,21 @@ wr_read_indeps (void) for (j = 0; j < n_cols; j++) { - if (!mget_token ()) + struct matrix_token token; + if (!mget_token (&token, mx->reader)) return 0; - if (mtoken != MNUM) + if (token.type != MNUM) { msg (SE, _("Syntax error expecting value for %s %s."), - default_dict.var[first_continuous + j]->name, context ()); + dict_get_var (default_dict, mx->first_continuous + j)->name, + context (mx->reader)); return 0; } - *cp++ = mtokval; + *cp++ = token.number; } - if (!force_eol (content_names[wr_content])) + if (mx->fmt != FREE + && !force_eol (mx->reader, content_names[wr->content])) return 0; debug_printf (("\n")); } @@ -2008,14 +1980,20 @@ wr_read_indeps (void) /* Matrix source. */ -struct case_stream matrix_data_source = +static const struct case_source_class matrix_data_with_rowtype_source_class = { + "MATRIX DATA", NULL, + matrix_data_read_with_rowtype, NULL, + }; + +static const struct case_source_class +matrix_data_without_rowtype_source_class = + { + "MATRIX DATA", NULL, + matrix_data_read_without_rowtype, NULL, - NULL, - NULL, - "MATRIX DATA", };