/* PSPP - computes sample statistics.
Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
#include <data/procedure.h>
#include <data/transformations.h>
#include <data/variable.h>
+#include <data/vector.h>
#include <language/command.h>
#include <language/expressions/public.h>
#include <language/lexer/lexer.h>
/* Variable lvalue, if variable != NULL. */
struct variable *variable; /* Destination variable, if any. */
- int fv; /* `value' index of destination variable. */
int width; /* Lvalue string width; 0=numeric. */
/* Vector lvalue, if vector != NULL. */
struct expression *rvalue; /* Rvalue expression. */
};
-static struct expression *parse_rvalue (struct lexer *lexer,
- const struct lvalue *,
+static struct expression *parse_rvalue (struct lexer *lexer,
+ const struct lvalue *,
struct dataset *);
static struct compute_trns *compute_trns_create (void);
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
- case_data_rw (c, compute->fv)->f = expr_evaluate_num (compute->rvalue, c,
- case_num);
-
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ case_data_rw (c, compute->variable)->f
+ = expr_evaluate_num (compute->rvalue, c, case_num);
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
{
double index; /* Index into the vector. */
int rindx; /* Rounded index value. */
index = expr_evaluate_num (compute->element, c, case_num);
rindx = floor (index + EPSILON);
- if (index == SYSMIS || rindx < 1 || rindx > compute->vector->cnt)
+ if (index == SYSMIS
+ || rindx < 1 || rindx > vector_get_var_cnt (compute->vector))
{
if (index == SYSMIS)
- msg (SW, _("When executing COMPUTE: SYSMIS is not a valid value as "
- "an index into vector %s."), compute->vector->name);
+ msg (SW, _("When executing COMPUTE: SYSMIS is not a valid value "
+ "as an index into vector %s."),
+ vector_get_name (compute->vector));
else
msg (SW, _("When executing COMPUTE: %g is not a valid value as "
"an index into vector %s."),
- index, compute->vector->name);
+ index, vector_get_name (compute->vector));
return TRNS_CONTINUE;
}
- case_data_rw (c, compute->vector->var[rindx - 1]->fv)->f
+ case_data_rw (c, vector_get_var (compute->vector, rindx - 1))->f
= expr_evaluate_num (compute->rvalue, c, case_num);
}
-
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
expr_evaluate_str (compute->rvalue, c, case_num,
- case_data_rw (c, compute->fv)->s, compute->width);
-
+ case_data_rw (c, compute->variable)->s, compute->width);
+
return TRNS_CONTINUE;
}
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || expr_evaluate_num (compute->test, c, case_num) == 1.0)
+ || expr_evaluate_num (compute->test, c, case_num) == 1.0)
{
double index; /* Index into the vector. */
int rindx; /* Rounded index value. */
index = expr_evaluate_num (compute->element, c, case_num);
rindx = floor (index + EPSILON);
- if (index == SYSMIS)
+ if (index == SYSMIS)
{
msg (SW, _("When executing COMPUTE: SYSMIS is not a valid "
"value as an index into vector %s."),
- compute->vector->name);
- return TRNS_CONTINUE;
+ vector_get_name (compute->vector));
+ return TRNS_CONTINUE;
}
- else if (rindx < 1 || rindx > compute->vector->cnt)
+ else if (rindx < 1 || rindx > vector_get_var_cnt (compute->vector))
{
msg (SW, _("When executing COMPUTE: %g is not a valid value as "
"an index into vector %s."),
- index, compute->vector->name);
+ index, vector_get_name (compute->vector));
return TRNS_CONTINUE;
}
- vr = compute->vector->var[rindx - 1];
+ vr = vector_get_var (compute->vector, rindx - 1);
expr_evaluate_str (compute->rvalue, c, case_num,
- case_data_rw (c, vr->fv)->s, vr->width);
+ case_data_rw (c, vr)->s,
+ var_get_width (vr));
}
-
+
return TRNS_CONTINUE;
}
\f
/* Code common to COMPUTE and IF. */
static trns_proc_func *
-get_proc_func (const struct lvalue *lvalue)
+get_proc_func (const struct lvalue *lvalue)
{
- bool is_numeric = lvalue_get_type (lvalue) == NUMERIC;
+ bool is_numeric = lvalue_get_type (lvalue) == VAR_NUMERIC;
bool is_vector = lvalue_is_vector (lvalue);
return (is_numeric
/* Parses and returns an rvalue expression of the same type as
LVALUE, or a null pointer on failure. */
static struct expression *
-parse_rvalue (struct lexer *lexer,
+parse_rvalue (struct lexer *lexer,
const struct lvalue *lvalue, struct dataset *ds)
{
- bool is_numeric = lvalue_get_type (lvalue) == NUMERIC;
+ bool is_numeric = lvalue_get_type (lvalue) == VAR_NUMERIC;
return expr_parse (lexer, ds, is_numeric ? EXPR_NUMBER : EXPR_STRING);
}
{
struct compute_trns *compute = compute_;
- if (compute != NULL)
+ if (compute != NULL)
{
expr_free (compute->test);
expr_free (compute->element);
/* Parses the target variable or vector element into a new
`struct lvalue', which is returned. */
static struct lvalue *
-lvalue_parse (struct lexer *lexer, struct dataset *ds)
+lvalue_parse (struct lexer *lexer, struct dataset *ds)
{
struct dictionary *dict = dataset_dict (ds);
struct lvalue *lvalue;
if (!lex_force_id (lexer))
goto lossage;
-
+
if (lex_look_ahead (lexer) == '(')
{
/* Vector. */
/* Variable name. */
const char *var_name = lex_tokid (lexer);
lvalue->variable = dict_lookup_var (dict, var_name);
- if (lvalue->variable == NULL)
+ if (lvalue->variable == NULL)
{
lvalue->variable = dict_create_var_assert (dict, var_name, 0);
- lvalue->is_new_variable = true;
+ lvalue->is_new_variable = true;
}
lex_get (lexer);
}
/* Returns the type (NUMERIC or ALPHA) of the target variable or
vector in LVALUE. */
static int
-lvalue_get_type (const struct lvalue *lvalue)
+lvalue_get_type (const struct lvalue *lvalue)
{
return (lvalue->variable != NULL
- ? lvalue->variable->type
- : lvalue->vector->var[0]->type);
+ ? var_get_type (lvalue->variable)
+ : vector_get_type (lvalue->vector));
}
/* Returns true if LVALUE has a vector as its target. */
static bool
-lvalue_is_vector (const struct lvalue *lvalue)
+lvalue_is_vector (const struct lvalue *lvalue)
{
return lvalue->vector != NULL;
}
/* Finalizes making LVALUE the target of COMPUTE, by creating the
target variable if necessary and setting fields in COMPUTE. */
static void
-lvalue_finalize (struct lvalue *lvalue,
- struct compute_trns *compute,
- struct dictionary *dict)
+lvalue_finalize (struct lvalue *lvalue,
+ struct compute_trns *compute,
+ struct dictionary *dict)
{
if (lvalue->vector == NULL)
{
compute->variable = lvalue->variable;
- compute->fv = compute->variable->fv;
- compute->width = compute->variable->width;
+ compute->width = var_get_width (compute->variable);
/* Goofy behavior, but compatible: Turn off LEAVE. */
- if (dict_class_from_id (compute->variable->name) != DC_SCRATCH)
- compute->variable->leave = false;
+ if (!var_must_leave (compute->variable))
+ var_set_leave (compute->variable, false);
/* Prevent lvalue_destroy from deleting variable. */
lvalue->is_new_variable = false;
}
- else
+ else
{
compute->vector = lvalue->vector;
compute->element = lvalue->element;
}
/* Destroys LVALUE. */
-static void
-lvalue_destroy (struct lvalue *lvalue, struct dictionary *dict)
+static void
+lvalue_destroy (struct lvalue *lvalue, struct dictionary *dict)
{
- if (lvalue == NULL)
+ if (lvalue == NULL)
return;
if (lvalue->is_new_variable)