/* 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 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 (char *, int *);
static void attach_mxd_aux (struct variable *, int var_type, int sub_type);
int
-cmd_matrix_data (void)
+cmd_matrix_data (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);
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);
}
goto lossage;
}
- if (dict_lookup_var (dataset_dict (current_dataset), tokid) == NULL
+ if (dict_lookup_var (dataset_dict (ds), tokid) == NULL
&& (lex_look_ahead () == '.' || lex_look_ahead () == '/'))
{
if (!strcasecmp (tokid, "ROWTYPE_")
goto lossage;
}
- mx->single_split = dict_create_var_assert (dataset_dict (current_dataset),
+ mx->single_split = dict_create_var_assert (dataset_dict (ds),
tokid, 0);
attach_mxd_aux (mx->single_split, MXD_CONTINUOUS, 0);
lex_get ();
- 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 (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++)
}
seen |= 4;
- if (!parse_variables (dataset_dict (current_dataset), &mx->factors, &mx->n_factors,
+ if (!parse_variables (dataset_dict (ds), &mx->factors, &mx->n_factors,
PV_NONE))
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;
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;
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;
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