/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
+ Copyright (C) 1997-9, 2000, 2006 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
#include <libpspp/pool.h>
#include <libpspp/str.h>
+#include "minmax.h"
#include "size_max.h"
#include "gettext.h"
const void *pb);
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 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 (struct dataset *ds)
+cmd_matrix_data (struct lexer *lexer, struct dataset *ds)
{
struct pool *pool;
struct matrix_data_pgm *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;
{
"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 (ds), 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_."));
}
mx->single_split = dict_create_var_assert (dataset_dict (ds),
- tokid, 0);
+ lex_tokid (lexer), 0);
attach_mxd_aux (mx->single_split, MXD_CONTINUOUS, 0);
- lex_get ();
+ lex_get (lexer);
dict_set_split_vars (dataset_dict (ds), &mx->single_split, 1);
}
struct variable **split;
size_t n;
- if (!parse_variables (dataset_dict (ds), &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 (ds), split, n);
for (i = 0; i < split_cnt; i++)
{
- struct mxd_var *mv = split[i]->aux;
- assert (mv != NULL);
+ struct mxd_var *mv = var_get_aux (split[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 (ds), &mx->factors, &mx->n_factors,
+ if (!parse_variables (lexer, dataset_dict (ds), &mx->factors, &mx->n_factors,
PV_NONE))
goto lossage;
for (i = 0; i < mx->n_factors; i++)
{
struct variable *v = mx->factors[i];
- struct mxd_var *mv = v->aux;
- assert (mv != NULL);
+ struct mxd_var *mv = var_get_aux (v);
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;
}
for (i = 0; i < dict_get_var_cnt (dataset_dict (ds)); i++)
{
struct variable *v = dict_get_var (dataset_dict (ds), i);
- struct mxd_var *mv = v->aux;
+ struct mxd_var *mv = var_get_aux (v);
int type = mv->var_type;
assert (type >= 0 && type < MXD_COUNT);
- v->print = v->write = fmt_tab[type];
+ var_set_both_formats (v, &fmt_tab[type]);
if (type == MXD_CONTINUOUS)
mx->n_continuous++;
goto lossage;
}
- mx->reader = dfm_open_reader (fh);
+ mx->reader = dfm_open_reader (fh, lexer);
if (mx->reader == NULL)
goto lossage;
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
{
{
struct variable *const *pa = a_;
struct variable *const *pb = b_;
- const struct mxd_var *a = (*pa)->aux;
- const struct mxd_var *b = (*pb)->aux;
+ const struct mxd_var *a = var_get_aux (*pa);
+ const struct mxd_var *b = var_get_aux (*pb);
if (a->var_type != b->var_type)
return a->var_type > b->var_type ? 1 : -1;
{
struct mxd_var *mv;
- assert (v->aux == NULL);
+ assert (var_get_aux (v) == NULL);
mv = xmalloc (sizeof *mv);
mv->var_type = var_type;
mv->sub_type = sub_type;
s = ss_buffer (start, ss_data (p) - start);
if (is_num)
- {
- struct data_in di;
-
- di.s = ss_data (s);
- 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);
-
- data_in (&di);
- }
+ data_in (s, FMT_F, 0,
+ dfm_get_column (reader, ss_data (s)),
+ (union value *) &token->number, 0);
else
token->type = MSTR;
}
if (token.type != MNUM)
{
msg (SE, _("expecting value for %s %s"),
- dict_get_var (nr->dict, j)->name,
+ var_get_name (dict_get_var (nr->dict, j)),
context (mx->reader));
return 0;
}
{
if (!compare)
{
- struct mxd_var *mv = dict_get_split_vars (nr->dict)[0]->aux;
+ struct mxd_var *mv = var_get_aux (dict_get_split_vars (nr->dict)[0]);
nr->split_values[0] = ++mv->sub_type;
}
return true;
{
msg (SE, _("Expecting value %g for %s."),
nr->split_values[i],
- dict_get_split_vars (nr->dict)[i]->name);
+ var_get_name (dict_get_split_vars (nr->dict)[i]));
return false;
}
}
{
msg (SE, _("Syntax error expecting value %g for %s %s."),
nr->factor_values[i + mx->n_factors * cell],
- mx->factors[i]->name, context (mx->reader));
+ var_get_name (mx->factors[i]), context (mx->reader));
return false;
}
}
int type = content_type[content];
{
- buf_copy_str_rpad (case_data_rw (c, mx->rowtype_->fv)->s, 8,
+ buf_copy_str_rpad (case_data_rw (c, mx->rowtype_)->s, 8,
content_names[content]);
if (type != 1)
- memset (case_data_rw (c, mx->varname_->fv)->s, ' ', 8);
+ memset (case_data_rw (c, mx->varname_)->s, ' ', 8);
}
{
for (j = 0; j < mx->n_continuous; j++)
{
- int fv = dict_get_var (dict, mx->first_continuous + j)->fv;
- case_data_rw (c, fv)->f = *cp;
+ struct variable *v = dict_get_var (dict, mx->first_continuous + j);
+ case_data_rw (c, v)->f = *cp;
cp++;
}
if (type == 1)
- buf_copy_str_rpad (case_data_rw (c, mx->varname_->fv)->s, 8,
- dict_get_var (dict,
- mx->first_continuous + i)->name);
+ buf_copy_str_rpad (case_data_rw (c, mx->varname_)->s, 8,
+ var_get_name (
+ dict_get_var (dict, mx->first_continuous + i)));
if (!write_case (wc_data))
return false;
}
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];
+ case_data_rw (c, split[i])->f = nr->split_values[i];
}
if (mx->n_factors)
size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
- case_data_rw (c, mx->factors[factor]->fv)->f
+ case_data_rw (c, mx->factors[factor])->f
= nr->factor_values[factor + cell * mx->n_factors];
}
size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
- case_data_rw (c, mx->factors[factor]->fv)->f = SYSMIS;
+ case_data_rw (c, mx->factors[factor])->f = SYSMIS;
}
for (content = 0; content <= PROX; content++)
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];
+ case_data_rw (c, split[i])->f = wr->split_values[i];
}
/* Sort the wr->data list. */
size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
- case_data_rw (c, mx->factors[factor]->fv)->f
- = iter->factors[factor];
+ case_data_rw (c, mx->factors[factor])->f = iter->factors[factor];
}
{
char s[16];
char *cp;
- memcpy (s, token->string, min (15, token->length));
- s[min (15, token->length)] = 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);
if (token.type != MNUM)
{
msg (SE, _("Syntax error expecting value for %s %s."),
- dict_get_var (wr->dict, mx->first_continuous + j)->name,
+ var_get_name (dict_get_var (wr->dict,
+ mx->first_continuous + j)),
context (mx->reader));
return false;
}
projects / pspp-builds.git / blobdiff