X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fxforms%2Fcompute.c;h=5c330f65a823e746a8dfefa854f79ff142529e56;hb=b0a400eb4ab34438115c4be640a43c9b0b3bf7ad;hp=bcede8a378ff58ef31f7e54c8bdf1c8c843297bc;hpb=480a0746507ce73d26f528b56dc3ed80195096e0;p=pspp diff --git a/src/language/xforms/compute.c b/src/language/xforms/compute.c index bcede8a378..5c330f65a8 100644 --- a/src/language/xforms/compute.c +++ b/src/language/xforms/compute.c @@ -1,39 +1,39 @@ -/* PSPP - computes sample statistics. - Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. +/* PSPP - a program for statistical analysis. + Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2014 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 . */ #include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "data/case.h" +#include "data/dataset.h" +#include "data/dictionary.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/message.h" +#include "libpspp/misc.h" +#include "libpspp/str.h" + +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -41,6 +41,18 @@ struct compute_trns; struct lvalue; +/* 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 + { + 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. */ + }; + /* Target of a COMPUTE or IF assignment, either a variable or a vector element. */ static struct lvalue *lvalue_parse (struct lexer *lexer, struct dataset *); @@ -68,13 +80,13 @@ struct compute_trns 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); -static trns_proc_func *get_proc_func (const struct lvalue *); -static trns_free_func compute_trns_free; +static bool compute_trns_free (void *compute_); +static const struct trns_class *get_trns_class (const struct lvalue *); /* COMPUTE. */ @@ -91,17 +103,17 @@ cmd_compute (struct lexer *lexer, struct dataset *ds) if (lvalue == NULL) goto fail; - if (!lex_force_match (lexer, '=')) + if (!lex_force_match (lexer, T_EQUALS)) goto fail; compute->rvalue = parse_rvalue (lexer, lvalue, ds); if (compute->rvalue == NULL) goto fail; - add_transformation (ds, get_proc_func (lvalue), compute_trns_free, compute); + add_transformation (ds, get_trns_class (lvalue), compute); lvalue_finalize (lvalue, compute, dict); - return lex_end_of_command (lexer); + return CMD_SUCCESS; fail: lvalue_destroy (lvalue, dict); @@ -112,105 +124,116 @@ cmd_compute (struct lexer *lexer, struct dataset *ds) /* Transformation functions. */ /* Handle COMPUTE or IF with numeric target variable. */ -static int -compute_num (void *compute_, struct ccase *c, casenumber case_num) +static enum trns_result +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->variable)->f - = expr_evaluate_num (compute->rvalue, c, case_num); - + || expr_evaluate_num (compute->test, *c, case_num) == 1.0) + { + *c = case_unshare (*c); + *case_num_rw (*c, compute->variable) + = 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, casenumber case_num) +static enum trns_result +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 > vector_get_var_cnt (compute->vector)) + || rindx < 1 || rindx > vector_get_n_vars (compute->vector)) { if (index == SYSMIS) 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 " + msg (SW, _("When executing COMPUTE: %.*g is not a valid value as " "an index into vector %s."), - index, vector_get_name (compute->vector)); + DBL_DIG + 1, index, vector_get_name (compute->vector)); return TRNS_CONTINUE; } - case_data_rw (c, vector_get_var (compute->vector, rindx - 1))->f - = expr_evaluate_num (compute->rvalue, c, case_num); + + *c = case_unshare (*c); + *case_num_rw (*c, vector_get_var (compute->vector, rindx - 1)) + = 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, casenumber case_num) +static enum trns_result +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->variable)->s, compute->width); - + || expr_evaluate_num (compute->test, *c, case_num) == 1.0) + { + char *s; + + *c = case_unshare (*c); + s = CHAR_CAST_BUG (char *, case_str_rw (*c, compute->variable)); + expr_evaluate_str (compute->rvalue, *c, case_num, s, 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, casenumber case_num) +static enum trns_result +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."), vector_get_name (compute->vector)); - return TRNS_CONTINUE; + return TRNS_CONTINUE; } - else if (rindx < 1 || rindx > vector_get_var_cnt (compute->vector)) + else if (rindx < 1 || rindx > vector_get_n_vars (compute->vector)) { - msg (SW, _("When executing COMPUTE: %g is not a valid value as " + msg (SW, _("When executing COMPUTE: %.*g is not a valid value as " "an index into vector %s."), - index, vector_get_name (compute->vector)); + DBL_DIG + 1, index, vector_get_name (compute->vector)); return TRNS_CONTINUE; } vr = vector_get_var (compute->vector, rindx - 1); - expr_evaluate_str (compute->rvalue, c, case_num, - case_data_rw (c, vr)->s, + *c = case_unshare (*c); + expr_evaluate_str (compute->rvalue, *c, case_num, + CHAR_CAST_BUG (char *, case_str_rw (*c, vr)), var_get_width (vr)); } - + return TRNS_CONTINUE; } @@ -226,7 +249,7 @@ cmd_if (struct lexer *lexer, struct dataset *ds) compute = compute_trns_create (); /* Test expression. */ - compute->test = expr_parse (lexer, ds, EXPR_BOOLEAN); + compute->test = expr_parse_bool (lexer, ds); if (compute->test == NULL) goto fail; @@ -236,17 +259,17 @@ cmd_if (struct lexer *lexer, struct dataset *ds) goto fail; /* Rvalue expression. */ - if (!lex_force_match (lexer, '=')) + if (!lex_force_match (lexer, T_EQUALS)) goto fail; compute->rvalue = parse_rvalue (lexer, lvalue, ds); if (compute->rvalue == NULL) goto fail; - add_transformation (ds, get_proc_func (lvalue), compute_trns_free, compute); + add_transformation (ds, get_trns_class (lvalue), compute); lvalue_finalize (lvalue, compute, dict); - return lex_end_of_command (lexer); + return CMD_SUCCESS; fail: lvalue_destroy (lvalue, dict); @@ -256,26 +279,47 @@ cmd_if (struct lexer *lexer, struct dataset *ds) /* Code common to COMPUTE and IF. */ -static trns_proc_func * -get_proc_func (const struct lvalue *lvalue) +static const struct trns_class * +get_trns_class (const struct lvalue *lvalue) { - bool is_numeric = lvalue_get_type (lvalue) == VAR_NUMERIC; - bool is_vector = lvalue_is_vector (lvalue); + static const struct trns_class classes[2][2] = { + [false][false] = { + .name = "COMPUTE", + .execute = compute_str, + .destroy = compute_trns_free + }, + [false][true] = { + .name = "COMPUTE", + .execute = compute_str_vec, + .destroy = compute_trns_free + }, + [true][false] = { + .name = "COMPUTE", + .execute = compute_num, + .destroy = compute_trns_free + }, + [true][true] = { + .name = "COMPUTE", + .execute = compute_num_vec, + .destroy = compute_trns_free + }, + }; - return (is_numeric - ? (is_vector ? compute_num_vec : compute_num) - : (is_vector ? compute_str_vec : compute_str)); + bool is_numeric = lvalue_get_type (lvalue) == VAL_NUMERIC; + bool is_vector = lvalue_is_vector (lvalue); + return &classes[is_numeric][is_vector]; } /* 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) == VAR_NUMERIC; - - return expr_parse (lexer, ds, is_numeric ? EXPR_NUMBER : EXPR_STRING); + if (lvalue->is_new_variable) + return expr_parse_new_variable (lexer, ds, var_get_name (lvalue->variable)); + else + return expr_parse (lexer, ds, lvalue_get_type (lvalue)); } /* Returns a new struct compute_trns after initializing its fields. */ @@ -297,7 +341,7 @@ compute_trns_free (void *compute_) { struct compute_trns *compute = compute_; - if (compute != NULL) + if (compute != NULL) { expr_free (compute->test); expr_free (compute->element); @@ -307,22 +351,10 @@ compute_trns_free (void *compute_) return true; } -/* 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 - { - 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 (struct lexer *lexer, struct dataset *ds) +lvalue_parse (struct lexer *lexer, struct dataset *ds) { struct dictionary *dict = dataset_dict (ds); struct lvalue *lvalue; @@ -335,36 +367,36 @@ lvalue_parse (struct lexer *lexer, struct dataset *ds) if (!lex_force_id (lexer)) goto lossage; - - if (lex_look_ahead (lexer) == '(') + + if (lex_next_token (lexer, 1) == T_LPAREN) { /* Vector. */ - lvalue->vector = dict_lookup_vector (dict, lex_tokid (lexer)); + lvalue->vector = dict_lookup_vector (dict, lex_tokcstr (lexer)); if (lvalue->vector == NULL) { - msg (SE, _("There is no vector named %s."), lex_tokid (lexer)); + msg (SE, _("There is no vector named %s."), lex_tokcstr (lexer)); goto lossage; } /* Vector element. */ lex_get (lexer); - if (!lex_force_match (lexer, '(')) + if (!lex_force_match (lexer, T_LPAREN)) goto lossage; - lvalue->element = expr_parse (lexer, ds, EXPR_NUMBER); + lvalue->element = expr_parse (lexer, ds, VAL_NUMERIC); if (lvalue->element == NULL) goto lossage; - if (!lex_force_match (lexer, ')')) + if (!lex_force_match (lexer, T_RPAREN)) goto lossage; } else { /* Variable name. */ - const char *var_name = lex_tokid (lexer); + const char *var_name = lex_tokcstr (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); } @@ -378,7 +410,7 @@ lvalue_parse (struct lexer *lexer, struct dataset *ds) /* 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 ? var_get_type (lvalue->variable) @@ -387,7 +419,7 @@ lvalue_get_type (const struct lvalue *lvalue) /* 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; } @@ -395,9 +427,9 @@ lvalue_is_vector (const struct lvalue *lvalue) /* 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) { @@ -411,7 +443,7 @@ lvalue_finalize (struct lvalue *lvalue, /* Prevent lvalue_destroy from deleting variable. */ lvalue->is_new_variable = false; } - else + else { compute->vector = lvalue->vector; compute->element = lvalue->element; @@ -422,10 +454,10 @@ lvalue_finalize (struct lvalue *lvalue, } /* 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)