/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
Written by Ben Pfaff <blp@gnu.org>.
This program is free software; you can redistribute it and/or
};
/* Name of each content type. */
-static const char *content_names[PROX + 1] =
+static const char *const content_names[PROX + 1] =
{
"N", "N", "N_MATRIX", "MEAN", "STDDEV", "COUNT", "MSE",
"DFE", "MAT", "COV", "CORR", "PROX",
/* Continuous variables. */
int n_continuous; /* Number of continuous variables. */
- int first_continuous; /* Index into dataset_dict (current_dataset).var of
+ int first_continuous; /* Index into dictionary of
first continuous variable. */
};
static int compare_variables_by_mxd_var_type (const void *pa,
const void *pb);
-static bool read_matrices_without_rowtype (struct matrix_data_pgm *);
-static bool read_matrices_with_rowtype (struct matrix_data_pgm *);
-static int string_to_content_type (char *, int *);
+static bool read_matrices_without_rowtype (struct dataset *ds, struct matrix_data_pgm *);
+static bool read_matrices_with_rowtype (struct dataset *ds, struct matrix_data_pgm *);
+static int string_to_content_type (const char *, int *);
static void attach_mxd_aux (struct variable *, int var_type, int sub_type);
int
-cmd_matrix_data (void)
+cmd_matrix_data (struct lexer *lexer, struct dataset *ds)
{
struct pool *pool;
struct matrix_data_pgm *mx;
unsigned seen = 0;
- discard_variables (current_dataset);
+ discard_variables (ds);
pool = pool_create ();
mx = pool_alloc (pool, sizeof *mx);
mx->n_contents = 0;
mx->n_continuous = 0;
mx->first_continuous = 0;
- while (token != '.')
+ while (lex_token (lexer) != '.')
{
- lex_match ('/');
+ lex_match (lexer, '/');
- if (lex_match_id ("VARIABLES"))
+ if (lex_match_id (lexer, "VARIABLES"))
{
char **v;
size_t nv;
}
seen |= 1;
- lex_match ('=');
- if (!parse_DATA_LIST_vars (&v, &nv, PV_NO_DUPLICATE))
+ lex_match (lexer, '=');
+ if (!parse_DATA_LIST_vars (lexer, &v, &nv, PV_NO_DUPLICATE))
goto lossage;
{
if (strcasecmp (v[i], "ROWTYPE_"))
{
- new_var = dict_create_var_assert (dataset_dict (current_dataset), v[i], 0);
+ new_var = dict_create_var_assert (dataset_dict (ds), v[i], 0);
attach_mxd_aux (new_var, MXD_CONTINUOUS, i);
}
else
free (v);
}
- mx->rowtype_ = dict_create_var_assert (dataset_dict (current_dataset),
+ mx->rowtype_ = dict_create_var_assert (dataset_dict (ds),
"ROWTYPE_", 8);
attach_mxd_aux (mx->rowtype_, MXD_ROWTYPE, 0);
}
- else if (lex_match_id ("FILE"))
+ else if (lex_match_id (lexer, "FILE"))
{
- lex_match ('=');
- fh = fh_parse (FH_REF_FILE | FH_REF_INLINE);
+ lex_match (lexer, '=');
+ fh = fh_parse (lexer, FH_REF_FILE | FH_REF_INLINE);
if (fh == NULL)
goto lossage;
}
- else if (lex_match_id ("FORMAT"))
+ else if (lex_match_id (lexer, "FORMAT"))
{
- lex_match ('=');
+ lex_match (lexer, '=');
- while (token == T_ID)
+ while (lex_token (lexer) == T_ID)
{
- if (lex_match_id ("LIST"))
+ if (lex_match_id (lexer, "LIST"))
mx->fmt = LIST;
- else if (lex_match_id ("FREE"))
+ else if (lex_match_id (lexer, "FREE"))
mx->fmt = FREE;
- else if (lex_match_id ("LOWER"))
+ else if (lex_match_id (lexer, "LOWER"))
mx->section = LOWER;
- else if (lex_match_id ("UPPER"))
+ else if (lex_match_id (lexer, "UPPER"))
mx->section = UPPER;
- else if (lex_match_id ("FULL"))
+ else if (lex_match_id (lexer, "FULL"))
mx->section = FULL;
- else if (lex_match_id ("DIAGONAL"))
+ else if (lex_match_id (lexer, "DIAGONAL"))
mx->diag = DIAGONAL;
- else if (lex_match_id ("NODIAGONAL"))
+ else if (lex_match_id (lexer, "NODIAGONAL"))
mx->diag = NODIAGONAL;
else
{
- lex_error (_("in FORMAT subcommand"));
+ lex_error (lexer, _("in FORMAT subcommand"));
goto lossage;
}
}
}
- else if (lex_match_id ("SPLIT"))
+ else if (lex_match_id (lexer, "SPLIT"))
{
- lex_match ('=');
+ lex_match (lexer, '=');
if (seen & 2)
{
}
seen |= 2;
- if (token != T_ID)
+ if (lex_token (lexer) != T_ID)
{
- lex_error (_("in SPLIT subcommand"));
+ lex_error (lexer, _("in SPLIT subcommand"));
goto lossage;
}
- if (dict_lookup_var (dataset_dict (current_dataset), tokid) == NULL
- && (lex_look_ahead () == '.' || lex_look_ahead () == '/'))
+ if (dict_lookup_var (dataset_dict (ds), lex_tokid (lexer)) == NULL
+ && (lex_look_ahead (lexer) == '.' || lex_look_ahead (lexer) == '/'))
{
- if (!strcasecmp (tokid, "ROWTYPE_")
- || !strcasecmp (tokid, "VARNAME_"))
+ if (!strcasecmp (lex_tokid (lexer), "ROWTYPE_")
+ || !strcasecmp (lex_tokid (lexer), "VARNAME_"))
{
msg (SE, _("Split variable may not be named ROWTYPE_ "
"or VARNAME_."));
goto lossage;
}
- mx->single_split = dict_create_var_assert (dataset_dict (current_dataset),
- tokid, 0);
+ mx->single_split = dict_create_var_assert (dataset_dict (ds),
+ lex_tokid (lexer), 0);
attach_mxd_aux (mx->single_split, MXD_CONTINUOUS, 0);
- lex_get ();
+ lex_get (lexer);
- dict_set_split_vars (dataset_dict (current_dataset), &mx->single_split, 1);
+ dict_set_split_vars (dataset_dict (ds), &mx->single_split, 1);
}
else
{
struct variable **split;
size_t n;
- if (!parse_variables (dataset_dict (current_dataset), &split, &n, PV_NO_DUPLICATE))
+ if (!parse_variables (lexer, dataset_dict (ds),
+ &split, &n, PV_NO_DUPLICATE))
goto lossage;
- dict_set_split_vars (dataset_dict (current_dataset), split, n);
+ dict_set_split_vars (dataset_dict (ds), split, n);
}
{
- struct variable *const *split = dict_get_split_vars (dataset_dict (current_dataset));
- size_t split_cnt = dict_get_split_cnt (dataset_dict (current_dataset));
+ struct variable *const *split = dict_get_split_vars (dataset_dict (ds));
+ size_t split_cnt = dict_get_split_cnt (dataset_dict (ds));
int i;
for (i = 0; i < split_cnt; i++)
if (mv->var_type != MXD_CONTINUOUS)
{
msg (SE, _("Split variable %s is already another type."),
- tokid);
+ lex_tokid (lexer));
goto lossage;
}
var_clear_aux (split[i]);
}
}
}
- else if (lex_match_id ("FACTORS"))
+ else if (lex_match_id (lexer, "FACTORS"))
{
- lex_match ('=');
+ lex_match (lexer, '=');
if (seen & 4)
{
}
seen |= 4;
- if (!parse_variables (dataset_dict (current_dataset), &mx->factors, &mx->n_factors,
+ if (!parse_variables (lexer, dataset_dict (ds), &mx->factors, &mx->n_factors,
PV_NONE))
goto lossage;
if (mv->var_type != MXD_CONTINUOUS)
{
msg (SE, _("Factor variable %s is already another type."),
- tokid);
+ lex_tokid (lexer));
goto lossage;
}
var_clear_aux (v);
}
}
}
- else if (lex_match_id ("CELLS"))
+ else if (lex_match_id (lexer, "CELLS"))
{
- lex_match ('=');
+ lex_match (lexer, '=');
if (mx->cells != -1)
{
goto lossage;
}
- if (!lex_is_integer () || lex_integer () < 1)
+ if (!lex_is_integer (lexer) || lex_integer (lexer) < 1)
{
- lex_error (_("expecting positive integer"));
+ lex_error (lexer, _("expecting positive integer"));
goto lossage;
}
- mx->cells = lex_integer ();
- lex_get ();
+ mx->cells = lex_integer (lexer);
+ lex_get (lexer);
}
- else if (lex_match_id ("N"))
+ else if (lex_match_id (lexer, "N"))
{
- lex_match ('=');
+ lex_match (lexer, '=');
if (mx->pop_n != -1)
{
goto lossage;
}
- if (!lex_is_integer () || lex_integer () < 1)
+ if (!lex_is_integer (lexer) || lex_integer (lexer) < 1)
{
- lex_error (_("expecting positive integer"));
+ lex_error (lexer, _("expecting positive integer"));
goto lossage;
}
- mx->pop_n = lex_integer ();
- lex_get ();
+ mx->pop_n = lex_integer (lexer);
+ lex_get (lexer);
}
- else if (lex_match_id ("CONTENTS"))
+ else if (lex_match_id (lexer, "CONTENTS"))
{
int inside_parens = 0;
unsigned collide = 0;
}
seen |= 8;
- lex_match ('=');
+ lex_match (lexer, '=');
{
int i;
for (;;)
{
- if (lex_match ('('))
+ if (lex_match (lexer, '('))
{
if (inside_parens)
{
inside_parens = 1;
item = LPAREN;
}
- else if (lex_match (')'))
+ else if (lex_match (lexer, ')'))
{
if (!inside_parens)
{
int content_type;
int collide_index;
- if (token != T_ID)
+ if (lex_token (lexer) != T_ID)
{
- lex_error (_("in CONTENTS subcommand"));
+ lex_error (lexer, _("in CONTENTS subcommand"));
goto lossage;
}
- content_type = string_to_content_type (tokid,
+ content_type = string_to_content_type (lex_tokid (lexer),
&collide_index);
if (content_type == -1)
{
- lex_error (_("in CONTENTS subcommand"));
+ lex_error (lexer, _("in CONTENTS subcommand"));
goto lossage;
}
- lex_get ();
+ lex_get (lexer);
if (collide & (1 << collide_index))
{
}
mx->contents[mx->n_contents++] = item;
- if (token == '/' || token == '.')
+ if (lex_token (lexer) == '/' || lex_token (lexer) == '.')
break;
}
}
else
{
- lex_error (NULL);
+ lex_error (lexer, NULL);
goto lossage;
}
}
- if (token != '.')
+ if (lex_token (lexer) != '.')
{
- lex_error (_("expecting end of command"));
+ lex_error (lexer, _("expecting end of command"));
goto lossage;
}
}
/* Create VARNAME_. */
- mx->varname_ = dict_create_var_assert (dataset_dict (current_dataset), "VARNAME_", 8);
+ mx->varname_ = dict_create_var_assert (dataset_dict (ds), "VARNAME_", 8);
attach_mxd_aux (mx->varname_, MXD_VARNAME, 0);
/* Sort the dictionary variables into the desired order for the
struct variable **v;
size_t nv;
- dict_get_vars (dataset_dict (current_dataset), &v, &nv, 0);
+ dict_get_vars (dataset_dict (ds), &v, &nv, 0);
qsort (v, nv, sizeof *v, compare_variables_by_mxd_var_type);
- dict_reorder_vars (dataset_dict (current_dataset), v, nv);
+ dict_reorder_vars (dataset_dict (ds), v, nv);
free (v);
}
int i;
mx->first_continuous = -1;
- for (i = 0; i < dict_get_var_cnt (dataset_dict (current_dataset)); i++)
+ for (i = 0; i < dict_get_var_cnt (dataset_dict (ds)); i++)
{
- struct variable *v = dict_get_var (dataset_dict (current_dataset), i);
+ struct variable *v = dict_get_var (dataset_dict (ds), i);
struct mxd_var *mv = v->aux;
int type = mv->var_type;
goto lossage;
}
- mx->reader = dfm_open_reader (fh);
+ mx->reader = dfm_open_reader (fh, lexer);
if (mx->reader == NULL)
goto lossage;
if (mx->explicit_rowtype)
- ok = read_matrices_with_rowtype (mx);
+ ok = read_matrices_with_rowtype (ds, mx);
else
- ok = read_matrices_without_rowtype (mx);
+ ok = read_matrices_without_rowtype (ds, mx);
dfm_close_reader (mx->reader);
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
lossage:
- discard_variables (current_dataset);
+ discard_variables (ds);
free (mx->factors);
pool_destroy (mx->container);
return CMD_CASCADING_FAILURE;
as a bit-index) which can be used for determining whether a related
statistic has already been used. */
static int
-string_to_content_type (char *s, int *collide)
+string_to_content_type (const char *s, int *collide)
{
static const struct
{
di.e = ss_end (s);
di.v = (union value *) &token->number;
di.f1 = dfm_get_column (reader, di.s);
- di.format = make_output_format (FMT_F, token->length, 0);
+ di.format = fmt_for_output (FMT_F, token->length, 0);
data_in (&di);
}
struct nr_aux_data
{
+ const struct dictionary *dict; /* The dictionary */
struct matrix_data_pgm *mx; /* MATRIX DATA program. */
double ***data; /* MATRIX DATA data. */
double *factor_values; /* Factor values. */
/* Read from the data file and write it to the active file.
Returns true if successful, false if an I/O error occurred. */
static bool
-read_matrices_without_rowtype (struct matrix_data_pgm *mx)
+read_matrices_without_rowtype (struct dataset *ds, struct matrix_data_pgm *mx)
{
struct nr_aux_data nr;
bool ok;
mx->cells = 1;
nr.mx = mx;
+ nr.dict = dataset_dict (ds);
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 (dataset_dict (current_dataset)),
+ nr.split_values = xnmalloc (dict_get_split_cnt (dataset_dict (ds)),
sizeof *nr.split_values);
- proc_set_source (current_dataset, create_case_source (
+ proc_set_source (ds, create_case_source (
&matrix_data_without_rowtype_source_class, &nr));
- ok = procedure (current_dataset,NULL, NULL);
+ ok = procedure (ds, NULL, NULL);
free (nr.split_values);
free (nr.factor_values);
if (token.type != MNUM)
{
msg (SE, _("expecting value for %s %s"),
- dict_get_var (dataset_dict (current_dataset), j)->name,
+ dict_get_var (nr->dict, j)->name,
context (mx->reader));
return 0;
}
if (!nr_output_data (nr, c, write_case, wc_data))
return false;
- if (dict_get_split_cnt (dataset_dict (current_dataset)) == 0
+ if (dict_get_split_cnt (nr->dict) == 0
|| !another_token (mx->reader))
return true;
}
return true;
}
- if (dict_get_split_vars (dataset_dict (current_dataset)) == NULL)
+ if (dict_get_split_vars (nr->dict) == NULL)
return true;
if (mx->single_split)
{
if (!compare)
{
- struct mxd_var *mv = dict_get_split_vars (dataset_dict (current_dataset))[0]->aux;
+ struct mxd_var *mv = dict_get_split_vars (nr->dict)[0]->aux;
nr->split_values[0] = ++mv->sub_type;
}
return true;
if (!compare)
just_read = 1;
- split_cnt = dict_get_split_cnt (dataset_dict (current_dataset));
+ split_cnt = dict_get_split_cnt (nr->dict);
for (i = 0; i < split_cnt; i++)
{
struct matrix_token token;
{
msg (SE, _("Expecting value %g for %s."),
nr->split_values[i],
- dict_get_split_vars (dataset_dict (current_dataset))[i]->name);
+ dict_get_split_vars (nr->dict)[i]->name);
return false;
}
}
CP to the active file.
Returns true if successful, false if an I/O error occurred. */
static bool
-dump_cell_content (struct matrix_data_pgm *mx, int content, double *cp,
+dump_cell_content (const struct dictionary *dict,
+ struct matrix_data_pgm *mx, int content, double *cp,
struct ccase *c,
write_case_func *write_case, write_case_data wc_data)
{
for (j = 0; j < mx->n_continuous; j++)
{
- int fv = dict_get_var (dataset_dict (current_dataset), mx->first_continuous + j)->fv;
+ int fv = dict_get_var (dict, mx->first_continuous + j)->fv;
case_data_rw (c, fv)->f = *cp;
cp++;
}
if (type == 1)
buf_copy_str_rpad (case_data_rw (c, mx->varname_->fv)->s, 8,
- dict_get_var (dataset_dict (current_dataset),
+ dict_get_var (dict,
mx->first_continuous + i)->name);
if (!write_case (wc_data))
return false;
size_t split_cnt;
size_t i;
- split_cnt = dict_get_split_cnt (dataset_dict (current_dataset));
- split = dict_get_split_vars (dataset_dict (current_dataset));
+ split_cnt = dict_get_split_cnt (nr->dict);
+ split = dict_get_split_vars (nr->dict);
for (i = 0; i < split_cnt; i++)
case_data_rw (c, split[i]->fv)->f = nr->split_values[i];
}
assert (nr->data[content] != NULL
&& nr->data[content][cell] != NULL);
- if (!dump_cell_content (mx, content, nr->data[content][cell],
+ if (!dump_cell_content (nr->dict, mx,
+ content, nr->data[content][cell],
c, write_case, wc_data))
return false;
}
for (content = 0; content <= PROX; content++)
if (!mx->is_per_factor[content] && nr->data[content] != NULL)
{
- if (!dump_cell_content (mx, content, nr->data[content][0],
+ if (!dump_cell_content (nr->dict, mx, content, nr->data[content][0],
c, write_case, wc_data))
return false;
}
/* With ROWTYPE_ auxiliary data. */
struct wr_aux_data
{
+ const struct dictionary *dict; /* The dictionary */
struct matrix_data_pgm *mx; /* MATRIX DATA program. */
int content; /* Type of current row. */
double *split_values; /* SPLIT FILE variable values. */
them to the output file.
Returns true if successful, false if an I/O error occurred. */
static bool
-read_matrices_with_rowtype (struct matrix_data_pgm *mx)
+read_matrices_with_rowtype (struct dataset *ds, struct matrix_data_pgm *mx)
{
struct wr_aux_data wr;
bool ok;
wr.split_values = NULL;
wr.data = NULL;
wr.current = NULL;
+ wr.dict = dataset_dict (ds);
mx->cells = 0;
- proc_set_source (current_dataset,
+ proc_set_source (ds,
create_case_source (&matrix_data_with_rowtype_source_class,
&wr));
- ok = procedure (current_dataset,NULL, NULL);
+ ok = procedure (ds, NULL, NULL);
free (wr.split_values);
return ok;
bool compare;
size_t split_cnt;
- split_cnt = dict_get_split_cnt (dataset_dict (current_dataset));
+ split_cnt = dict_get_split_cnt (wr->dict);
if (split_cnt == 0)
return true;
/* Compares doubles A and B, treating SYSMIS as greatest. */
static int
-compare_doubles (const void *a_, const void *b_, void *aux UNUSED)
+compare_doubles (const void *a_, const void *b_, const void *aux UNUSED)
{
const double *a = a_;
const double *b = b_;
/* 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_)
+compare_factors (const void *a_, const void *b_, const void *mx_)
{
- struct matrix_data_pgm *mx = mx_;
+ const struct matrix_data_pgm *mx = mx_;
struct factor_data *const *pa = a_;
struct factor_data *const *pb = b_;
const double *a = (*pa)->factors;
size_t split_cnt;
size_t i;
- split_cnt = dict_get_split_cnt (dataset_dict (current_dataset));
- split = dict_get_split_vars (dataset_dict (current_dataset));
+ split_cnt = dict_get_split_cnt (wr->dict);
+ split = dict_get_split_vars (wr->dict);
for (i = 0; i < split_cnt; i++)
case_data_rw (c, split[i]->fv)->f = wr->split_values[i];
}
fill_matrix (mx, content, iter->data[content]);
- ok = dump_cell_content (mx, content, iter->data[content],
+ ok = dump_cell_content (wr->dict, mx, content,
+ iter->data[content],
c, write_case, wc_data);
if (!ok)
break;
if (token.type != MNUM)
{
msg (SE, _("Syntax error expecting value for %s %s."),
- dict_get_var (dataset_dict (current_dataset), mx->first_continuous + j)->name,
+ dict_get_var (wr->dict, mx->first_continuous + j)->name,
context (mx->reader));
return false;
}
projects / pspp-builds.git / blobdiff