pintos-os.org Git - pspp/blob - src/language/control/do-if.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2009-2012 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <stdlib.h>
  20
  21 #include "data/dataset.h"
  22 #include "data/transformations.h"
  23 #include "language/command.h"
  24 #include "language/data-io/inpt-pgm.h"
  25 #include "language/expressions/public.h"
  26 #include "language/lexer/lexer.h"
  27 #include "libpspp/compiler.h"
  28 #include "libpspp/message.h"
  29 #include "libpspp/str.h"
  30
  31 #include "gl/xalloc.h"
  32
  33 #include "gettext.h"
  34 #define _(msgid) gettext (msgid)
  35
  36 /* A conditional clause. */
  37 struct clause
  38   {
  39     struct msg_location *location;
  40     struct expression *condition; /* Test expression; NULL for ELSE clause. */
  41     struct trns_chain xforms;
  42   };
  43
  44 /* DO IF transformation. */
  45 struct do_if_trns
  46   {
  47     struct clause *clauses;     /* Clauses. */
  48     size_t n_clauses;           /* Number of clauses. */
  49
  50     const struct trns_chain *resume;
  51     size_t ofs;
  52   };
  53
  54 static const struct trns_class do_if_trns_class;
  55
  56 static void
  57 start_clause (struct lexer *lexer, struct dataset *ds,
  58               bool condition, struct do_if_trns *do_if,
  59               size_t *allocated_clauses, bool *ok)
  60 {
  61   if (*ok && do_if->n_clauses > 0
  62       && !do_if->clauses[do_if->n_clauses - 1].condition)
  63     {
  64       if (condition)
  65         msg (SE, _("ELSE IF is not allowed following ELSE "
  66                    "within DO IF...END IF."));
  67       else
  68         msg (SE, _("Only one ELSE is allowed within DO IF...END IF."));
  69
  70       msg_at (SN, do_if->clauses[do_if->n_clauses - 1].location,
  71               _("This is the location of the previous ELSE clause."));
  72
  73       msg_at (SN, do_if->clauses[0].location,
  74               _("This is the location of the DO IF command."));
  75     }
  76
  77   if (do_if->n_clauses >= *allocated_clauses)
  78     do_if->clauses = x2nrealloc (do_if->clauses, allocated_clauses,
  79                                  sizeof *do_if->clauses);
  80   struct clause *clause = &do_if->clauses[do_if->n_clauses++];
  81
  82   *clause = (struct clause) { .location = NULL };
  83   if (condition)
  84     {
  85       clause->condition = expr_parse_bool (lexer, ds);
  86       if (!clause->condition)
  87         lex_discard_rest_of_command (lexer);
  88     }
  89   clause->location = lex_ofs_location (lexer, 0, lex_ofs (lexer));
  90
  91   lex_end_of_command (lexer);
  92   lex_get (lexer);
  93
  94   proc_push_transformations (ds);
  95 }
  96
  97 static void
  98 finish_clause (struct dataset *ds, struct do_if_trns *do_if)
  99 {
 100   struct clause *clause = &do_if->clauses[do_if->n_clauses - 1];
 101   proc_pop_transformations (ds, &clause->xforms);
 102 }
 103
 104 /* Parse DO IF. */
 105 int
 106 cmd_do_if (struct lexer *lexer, struct dataset *ds)
 107 {
 108   struct do_if_trns *do_if = xmalloc (sizeof *do_if);
 109   *do_if = (struct do_if_trns) { .n_clauses = 0 };
 110
 111   size_t allocated_clauses = 0;
 112   bool ok = true;
 113
 114   start_clause (lexer, ds, true, do_if, &allocated_clauses, &ok);
 115   while (!lex_match_phrase (lexer, "END IF"))
 116     {
 117       if (lex_token (lexer) == T_STOP)
 118         {
 119           lex_error (lexer, NULL);
 120           ok = false;
 121           break;
 122         }
 123       else if (lex_match_phrase (lexer, "ELSE IF"))
 124         {
 125           finish_clause (ds, do_if);
 126           start_clause (lexer, ds, true, do_if, &allocated_clauses, &ok);
 127         }
 128       else if (lex_match_id (lexer, "ELSE"))
 129         {
 130           finish_clause (ds, do_if);
 131           start_clause (lexer, ds, false, do_if, &allocated_clauses, &ok);
 132         }
 133       else
 134         cmd_parse_in_state (lexer, ds,
 135                             (in_input_program ()
 136                              ? CMD_STATE_NESTED_INPUT_PROGRAM
 137                              : CMD_STATE_NESTED_DATA));
 138     }
 139   finish_clause (ds, do_if);
 140
 141   add_transformation (ds, &do_if_trns_class, do_if);
 142
 143   return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
 144 }
 145
 146 int
 147 cmd_inside_do_if (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
 148 {
 149   msg (SE, _("This command cannot appear outside DO IF...END IF."));
 150   return CMD_FAILURE;
 151 }
 152
 153 static const struct trns_chain *
 154 do_if_find_clause (const struct do_if_trns *do_if,
 155                    struct ccase *c, casenumber case_num)
 156 {
 157   for (size_t i = 0; i < do_if->n_clauses; i++)
 158     {
 159       const struct clause *clause = &do_if->clauses[i];
 160       if (!clause->condition)
 161         return &clause->xforms;
 162
 163       double boolean = expr_evaluate_num (clause->condition, c, case_num);
 164       if (boolean != 0.0)
 165         return boolean == SYSMIS ? NULL : &clause->xforms;
 166     }
 167   return NULL;
 168 }
 169
 170 static enum trns_result
 171 do_if_trns_proc (void *do_if_, struct ccase **c, casenumber case_num)
 172 {
 173   struct do_if_trns *do_if = do_if_;
 174
 175   const struct trns_chain *chain;
 176   size_t start;
 177   if (do_if->resume)
 178     {
 179       chain = do_if->resume;
 180       start = do_if->ofs;
 181       do_if->resume = NULL;
 182       do_if->ofs = 0;
 183     }
 184   else
 185     {
 186       chain = do_if_find_clause (do_if, *c, case_num);
 187       if (!chain)
 188         return TRNS_CONTINUE;
 189       start = 0;
 190     }
 191
 192   for (size_t i = start; i < chain->n; i++)
 193     {
 194       const struct transformation *trns = &chain->xforms[i];
 195       enum trns_result r = trns->class->execute (trns->aux, c, case_num);
 196       switch (r)
 197         {
 198         case TRNS_CONTINUE:
 199           break;
 200
 201         case TRNS_BREAK:
 202         case TRNS_DROP_CASE:
 203         case TRNS_ERROR:
 204         case TRNS_END_FILE:
 205           return r;
 206
 207         case TRNS_END_CASE:
 208           do_if->resume = chain;
 209           do_if->ofs = i;
 210           return r;
 211         }
 212     }
 213   return TRNS_CONTINUE;
 214 }
 215
 216 static bool
 217 do_if_trns_free (void *do_if_)
 218 {
 219   struct do_if_trns *do_if = do_if_;
 220
 221   for (size_t i = 0; i < do_if->n_clauses; i++)
 222     {
 223       struct clause *clause = &do_if->clauses[i];
 224
 225       msg_location_destroy (clause->location);
 226       expr_free (clause->condition);
 227
 228       trns_chain_uninit (&clause->xforms);
 229     }
 230   free (do_if->clauses);
 231   free (do_if);
 232   return true;
 233 }
 234
 235 static const struct trns_class do_if_trns_class = {
 236   .name = "DO IF",
 237   .execute = do_if_trns_proc,
 238   .destroy = do_if_trns_free,
 239 };