#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,
struct variable *single_split; /* Single SPLIT FILE variable. */
/* Factor variables. */
- int n_factors; /* Number of 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? */
{
struct pool *pool;
struct matrix_data_pgm *mx;
- struct file_handle *fh = NULL;
+ struct file_handle *fh = fh_inline_file ();
unsigned seen = 0;
if (lex_match_id ("VARIABLES"))
{
char **v;
- int nv;
+ size_t nv;
if (seen & 1)
{
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."));
}
{
- 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 = dict_create_var_assert (default_dict, v[i], 0);
attach_mxd_aux (new_var, MXD_CONTINUOUS, i);
else if (lex_match_id ("FILE"))
{
lex_match ('=');
- fh = fh_parse ();
+ fh = fh_parse (FH_REF_FILE | FH_REF_INLINE);
if (fh == NULL)
goto lossage;
}
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_."));
else
{
struct variable **split;
- int n;
+ size_t n;
if (!parse_variables (default_dict, &split, &n, PV_NO_DUPLICATE))
goto lossage;
}
seen |= 4;
- if (!parse_variables (default_dict, &mx->factors, &mx->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 < mx->n_factors; i++)
{
};
for (tp = tab; tp->value != -1; tp++)
- if (!strcmp (s, tp->string))
+ if (!strcasecmp (s, tp->string))
{
if (collide)
*collide = tp->collide;
di.e = token->string + token->length;
di.v = (union value *) &token->number;
di.f1 = first_column;
- di.format.type = FMT_F;
- di.format.w = token->length;
- di.format.d = 0;
+ di.format = make_output_format (FMT_F, token->length, 0);
if (!data_in (&di))
return 0;
nr.mx = mx;
nr.data = NULL;
- nr.factor_values = xmalloc (sizeof *nr.factor_values * mx->n_factors * mx->cells);
+ nr.factor_values = xnmalloc (mx->n_factors * mx->cells,
+ sizeof *nr.factor_values);
nr.max_cell_idx = 0;
- nr.split_values = xmalloc (sizeof *nr.split_values
- * dict_get_split_cnt (default_dict));
+ 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);
{
int *cp;
- nr->data = pool_alloc (mx->container, (PROX + 1) * sizeof *nr->data);
+ nr->data = pool_nalloc (mx->container, PROX + 1, sizeof *nr->data);
{
int i;
int n_vectors = per_factor ? mx->cells : 1;
int i;
- nr->data[*cp] = pool_alloc (mx->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 (mx->container,
- n_entries * sizeof ***nr->data);
+ nr->data[*cp][i] = pool_nalloc (mx->container,
+ n_entries, sizeof ***nr->data);
}
}
}
}
{
- int i;
+ size_t i;
for (i = 0; i < mx->n_factors; i++)
{
int type = content_type[content];
{
- st_bare_pad_copy (case_data_rw (c, mx->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 (case_data_rw (c, mx->varname_->fv)->s, ' ', 8);
cp++;
}
if (type == 1)
- st_bare_pad_copy (case_data_rw (c, mx->varname_->fv)->s,
- dict_get_var (default_dict,
- mx->first_continuous + i)->name,
- 8);
+ 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);
}
}
for (cell = 0; cell < mx->cells; cell++)
{
{
- int factor;
+ size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
{
int content;
{
- int factor;
+ size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
case_data_rw (c, mx->factors[factor]->fv)->f = SYSMIS;
else
{
compare = 0;
- wr->split_values = xmalloc (split_cnt * sizeof *wr->split_values);
+ wr->split_values = xnmalloc (split_cnt, sizeof *wr->split_values);
}
{
struct factor_data *iter;
int i;
- factors = xmalloc (sizeof *factors * mx->cells);
+ factors = xnmalloc (mx->cells, sizeof *factors);
for (i = 0, iter = wr->data; iter; iter = iter->next, i++)
factors[i] = iter;
for (iter = wr->data; iter; iter = iter->next)
{
{
- int factor;
+ size_t factor;
for (factor = 0; factor < mx->n_factors; factor++)
case_data_rw (c, mx->factors[factor]->fv)->f
wr->content = -1;
{
- int i;
+ size_t i;
for (i = 0; i < mx->n_factors; i++)
{
mechanism. */
if (wr->current)
{
- int i;
+ size_t i;
for (i = 0; i < mx->n_factors; i++)
if (factor_values[i] != wr->current->factors[i])
for (iter = wr->data; iter; iter = iter->next)
{
- int i;
+ size_t i;
for (i = 0; i < mx->n_factors; i++)
if (factor_values[i] != iter->factors[i])
{
struct factor_data *new = pool_alloc (mx->container, sizeof *new);
- new->factors = pool_alloc (mx->container, sizeof *new->factors * mx->n_factors);
+ new->factors = pool_nalloc (mx->container,
+ mx->n_factors, sizeof *new->factors);
{
- int i;
+ size_t i;
for (i = 0; i < mx->n_factors; i++)
new->factors[i] = factor_values[i];
if (type == 1)
n_items *= mx->n_continuous;
- c->data[wr->content] = pool_alloc (mx->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 * mx->n_continuous];