-/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 1997-9, 2000, 2009 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
- published by the Free Software Foundation; either version 2 of the
- License, or (at your option) any later version.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
+#include <stdint.h>
#include <stdlib.h>
#include <data/case.h>
#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>
-#include <libpspp/alloc.h>
-#include <libpspp/message.h>
#include <libpspp/message.h>
#include <libpspp/misc.h>
#include <libpspp/str.h>
+#include "xalloc.h"
+
#include "gettext.h"
#define _(msgid) gettext (msgid)
/* Target of a COMPUTE or IF assignment, either a variable or a
vector element. */
-static struct lvalue *lvalue_parse (void);
+static struct lvalue *lvalue_parse (struct lexer *lexer, struct dataset *);
static int lvalue_get_type (const struct lvalue *);
static bool lvalue_is_vector (const struct lvalue *);
static void lvalue_finalize (struct lvalue *,
- struct compute_trns *);
-static void lvalue_destroy (struct lvalue *);
+ struct compute_trns *, struct dictionary *);
+static void lvalue_destroy (struct lvalue *, struct dictionary *);
/* COMPUTE and IF transformation. */
struct compute_trns
/* 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 (const struct lvalue *);
+static struct expression *parse_rvalue (struct lexer *lexer,
+ const struct lvalue *,
+ struct dataset *);
+
static struct compute_trns *compute_trns_create (void);
static trns_proc_func *get_proc_func (const struct lvalue *);
static trns_free_func compute_trns_free;
/* COMPUTE. */
int
-cmd_compute (void)
+cmd_compute (struct lexer *lexer, struct dataset *ds)
{
+ struct dictionary *dict = dataset_dict (ds);
struct lvalue *lvalue = NULL;
struct compute_trns *compute = NULL;
compute = compute_trns_create ();
- lvalue = lvalue_parse ();
+ lvalue = lvalue_parse (lexer, ds);
if (lvalue == NULL)
goto fail;
- if (!lex_force_match ('='))
+ if (!lex_force_match (lexer, '='))
goto fail;
- compute->rvalue = parse_rvalue (lvalue);
+ compute->rvalue = parse_rvalue (lexer, lvalue, ds);
if (compute->rvalue == NULL)
goto fail;
- add_transformation (get_proc_func (lvalue), compute_trns_free, compute);
+ add_transformation (ds, get_proc_func (lvalue), compute_trns_free, compute);
- lvalue_finalize (lvalue, compute);
+ lvalue_finalize (lvalue, compute, dict);
- return lex_end_of_command ();
+ return lex_end_of_command (lexer);
fail:
- lvalue_destroy (lvalue);
+ lvalue_destroy (lvalue, dict);
compute_trns_free (compute);
return CMD_CASCADING_FAILURE;
}
/* Handle COMPUTE or IF with numeric target variable. */
static int
-compute_num (void *compute_, struct ccase *c, int case_num)
+compute_num (void *compute_, struct ccase **c, casenumber case_num)
{
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)
+ {
+ *c = case_unshare (*c);
+ case_data_rw (*c, compute->variable)->f
+ = expr_evaluate_num (compute->rvalue, *c, case_num);
+ }
+
return TRNS_CONTINUE;
}
/* Handle COMPUTE or IF with numeric vector element target
variable. */
static int
-compute_num_vec (void *compute_, struct ccase *c, int case_num)
+compute_num_vec (void *compute_, struct ccase **c, casenumber case_num)
{
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);
+ 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
- = expr_evaluate_num (compute->rvalue, c, case_num);
+
+ *c = case_unshare (*c);
+ case_data_rw (*c, vector_get_var (compute->vector, rindx - 1))->f
+ = expr_evaluate_num (compute->rvalue, *c, case_num);
}
-
+
return TRNS_CONTINUE;
}
/* Handle COMPUTE or IF with string target variable. */
static int
-compute_str (void *compute_, struct ccase *c, int case_num)
+compute_str (void *compute_, struct ccase **c, casenumber case_num)
{
struct compute_trns *compute = compute_;
if (compute->test == NULL
- || 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);
-
+ || expr_evaluate_num (compute->test, *c, case_num) == 1.0)
+ {
+ *c = case_unshare (*c);
+ expr_evaluate_str (compute->rvalue, *c, case_num,
+ case_str_rw (*c, compute->variable),
+ compute->width);
+ }
+
return TRNS_CONTINUE;
}
/* Handle COMPUTE or IF with string vector element target
variable. */
static int
-compute_str_vec (void *compute_, struct ccase *c, int case_num)
+compute_str_vec (void *compute_, struct ccase **c, casenumber case_num)
{
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. */
struct variable *vr; /* Variable reference by indexed vector. */
- index = expr_evaluate_num (compute->element, c, case_num);
+ 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];
- expr_evaluate_str (compute->rvalue, c, case_num,
- case_data_rw (c, vr->fv)->s, vr->width);
+ vr = vector_get_var (compute->vector, rindx - 1);
+ *c = case_unshare (*c);
+ expr_evaluate_str (compute->rvalue, *c, case_num,
+ case_str_rw (*c, vr), var_get_width (vr));
}
-
+
return TRNS_CONTINUE;
}
\f
/* IF. */
int
-cmd_if (void)
+cmd_if (struct lexer *lexer, struct dataset *ds)
{
+ struct dictionary *dict = dataset_dict (ds);
struct compute_trns *compute = NULL;
struct lvalue *lvalue = NULL;
compute = compute_trns_create ();
/* Test expression. */
- compute->test = expr_parse (default_dict, EXPR_BOOLEAN);
+ compute->test = expr_parse (lexer, ds, EXPR_BOOLEAN);
if (compute->test == NULL)
goto fail;
/* Lvalue variable. */
- lvalue = lvalue_parse ();
+ lvalue = lvalue_parse (lexer, ds);
if (lvalue == NULL)
goto fail;
/* Rvalue expression. */
- if (!lex_force_match ('='))
+ if (!lex_force_match (lexer, '='))
goto fail;
- compute->rvalue = parse_rvalue (lvalue);
+ compute->rvalue = parse_rvalue (lexer, lvalue, ds);
if (compute->rvalue == NULL)
goto fail;
- add_transformation (get_proc_func (lvalue), compute_trns_free, compute);
+ add_transformation (ds, get_proc_func (lvalue), compute_trns_free, compute);
- lvalue_finalize (lvalue, compute);
+ lvalue_finalize (lvalue, compute, dict);
- return lex_end_of_command ();
+ return lex_end_of_command (lexer);
fail:
- lvalue_destroy (lvalue);
+ lvalue_destroy (lvalue, dict);
compute_trns_free (compute);
return CMD_CASCADING_FAILURE;
}
/* 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) == VAL_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 (const struct lvalue *lvalue)
+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) == VAL_NUMERIC;
- return expr_parse (default_dict, is_numeric ? EXPR_NUMBER : EXPR_STRING);
+ return expr_parse (lexer, ds, is_numeric ? EXPR_NUMBER : EXPR_STRING);
}
/* Returns a new struct compute_trns after initializing its fields. */
{
struct compute_trns *compute = compute_;
- if (compute != NULL)
+ if (compute != NULL)
{
expr_free (compute->test);
expr_free (compute->element);
return true;
}
\f
-/* COMPUTE or IF target variable or vector element. */
+/* COMPUTE or IF target variable or vector element.
+ For a variable, the `variable' member is non-null.
+ For a vector element, the `vector' member is non-null. */
struct lvalue
{
- char var_name[LONG_NAME_LEN + 1]; /* Destination variable name, or "". */
+ struct variable *variable; /* Destination variable. */
+ bool is_new_variable; /* Did we create the variable? */
+
const struct vector *vector; /* Destination vector, if any, or NULL. */
struct expression *element; /* Destination vector element, or NULL. */
};
/* Parses the target variable or vector element into a new
`struct lvalue', which is returned. */
static struct lvalue *
-lvalue_parse (void)
+lvalue_parse (struct lexer *lexer, struct dataset *ds)
{
+ struct dictionary *dict = dataset_dict (ds);
struct lvalue *lvalue;
lvalue = xmalloc (sizeof *lvalue);
- lvalue->var_name[0] = '\0';
+ lvalue->variable = NULL;
+ lvalue->is_new_variable = false;
lvalue->vector = NULL;
lvalue->element = NULL;
- if (!lex_force_id ())
+ if (!lex_force_id (lexer))
goto lossage;
-
- if (lex_look_ahead () == '(')
+
+ if (lex_look_ahead (lexer) == '(')
{
/* Vector. */
- lvalue->vector = dict_lookup_vector (default_dict, tokid);
+ lvalue->vector = dict_lookup_vector (dict, lex_tokid (lexer));
if (lvalue->vector == NULL)
{
- msg (SE, _("There is no vector named %s."), tokid);
+ msg (SE, _("There is no vector named %s."), lex_tokid (lexer));
goto lossage;
}
/* Vector element. */
- lex_get ();
- if (!lex_force_match ('('))
+ lex_get (lexer);
+ if (!lex_force_match (lexer, '('))
goto lossage;
- lvalue->element = expr_parse (default_dict, EXPR_NUMBER);
+ lvalue->element = expr_parse (lexer, ds, EXPR_NUMBER);
if (lvalue->element == NULL)
goto lossage;
- if (!lex_force_match (')'))
+ if (!lex_force_match (lexer, ')'))
goto lossage;
}
else
{
/* Variable name. */
- str_copy_trunc (lvalue->var_name, sizeof lvalue->var_name, tokid);
- lex_get ();
+ const char *var_name = lex_tokid (lexer);
+ lvalue->variable = dict_lookup_var (dict, var_name);
+ if (lvalue->variable == NULL)
+ {
+ lvalue->variable = dict_create_var_assert (dict, var_name, 0);
+ lvalue->is_new_variable = true;
+ }
+ lex_get (lexer);
}
return lvalue;
lossage:
- lvalue_destroy (lvalue);
+ lvalue_destroy (lvalue, dict);
return NULL;
}
/* 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)
{
- if (lvalue->vector == NULL)
- {
- struct variable *var = dict_lookup_var (default_dict, lvalue->var_name);
- if (var == NULL)
- return NUMERIC;
- else
- return var->type;
- }
- else
- return lvalue->vector->var[0]->type;
+ return (lvalue->variable != NULL
+ ? var_get_type (lvalue->variable)
+ : vector_get_type (lvalue->vector));
}
-/* Returns nonzero if LVALUE has a vector as its target. */
+/* 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)
+lvalue_finalize (struct lvalue *lvalue,
+ struct compute_trns *compute,
+ struct dictionary *dict)
{
if (lvalue->vector == NULL)
{
- compute->variable = dict_lookup_var (default_dict, lvalue->var_name);
- if (compute->variable == NULL)
- compute->variable = dict_create_var_assert (default_dict,
- lvalue->var_name, 0);
-
- compute->fv = compute->variable->fv;
- compute->width = compute->variable->width;
+ compute->variable = lvalue->variable;
+ 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;
lvalue->element = NULL;
}
- lvalue_destroy (lvalue);
+ lvalue_destroy (lvalue, dict);
}
/* Destroys LVALUE. */
-static void
-lvalue_destroy (struct lvalue *lvalue)
+static void
+lvalue_destroy (struct lvalue *lvalue, struct dictionary *dict)
{
- if (lvalue == NULL)
+ if (lvalue == NULL)
return;
+ if (lvalue->is_new_variable)
+ dict_delete_var (dict, lvalue->variable);
expr_free (lvalue->element);
free (lvalue);
}
projects / pspp-builds.git / blobdiff