7de886efd3e8dbe182caf8db73d1c82d8d1539a3
[pspp-builds.git] / src / language / control / do-if.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or
5    modify it under the terms of the GNU General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    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, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17    02110-1301, USA. */
18
19 #include <config.h>
20
21 #include <stdlib.h>
22
23 #include "control-stack.h"
24 #include <data/case.h>
25 #include <data/procedure.h>
26 #include <data/transformations.h>
27 #include <data/value.h>
28 #include <language/command.h>
29 #include <language/expressions/public.h>
30 #include <language/lexer/lexer.h>
31 #include <libpspp/alloc.h>
32 #include <libpspp/compiler.h>
33 #include <libpspp/message.h>
34 #include <libpspp/message.h>
35 #include <libpspp/str.h>
36
37 #include "gettext.h"
38 #define _(msgid) gettext (msgid)
39
40 /* DO IF, ELSE IF, and ELSE are translated as a single
41    transformation that evaluates each condition and jumps to the
42    start of the appropriate block of transformations.  Each block
43    of transformations (except for the last) ends with a
44    transformation that jumps past the remaining blocks.
45
46    So, the following code:
47
48        DO IF a.             
49        ...block 1...
50        ELSE IF b.
51        ...block 2...
52        ELSE.
53        ...block 3...
54        END IF.
55
56    is effectively translated like this:
57
58        IF a GOTO 1, IF b GOTO 2, ELSE GOTO 3.
59        1: ...block 1...
60           GOTO 4
61        2: ...block 2...
62           GOTO 4
63        3: ...block 3...
64        4:
65
66 */
67
68 /* A conditional clause. */
69 struct clause 
70   {
71     struct expression *condition; /* Test expression; NULL for ELSE clause. */
72     int target_index;           /* Transformation to jump to if true. */
73   };
74
75 /* DO IF transformation. */
76 struct do_if_trns
77   {
78     struct dataset *ds;         /* The dataset */
79     struct clause *clauses;     /* Clauses. */
80     size_t clause_cnt;          /* Number of clauses. */
81     int past_END_IF_index;      /* Transformation just past last clause. */
82   };
83
84 static const struct ctl_class do_if_class;
85
86 static int parse_clause (struct lexer *, struct do_if_trns *, struct dataset *ds);
87 static void add_clause (struct do_if_trns *,
88                         struct expression *condition, int target_index);
89 static void add_else (struct do_if_trns *);
90
91 static bool has_else (struct do_if_trns *);
92 static bool must_not_have_else (struct do_if_trns *);
93 static void close_do_if (void *do_if);
94
95 static trns_finalize_func do_if_finalize_func;
96 static trns_proc_func do_if_trns_proc, break_trns_proc;
97 static trns_free_func do_if_trns_free;
98
99 /* Parse DO IF. */
100 int
101 cmd_do_if (struct lexer *lexer, struct dataset *ds)
102 {
103   struct do_if_trns *do_if = xmalloc (sizeof *do_if);
104   do_if->clauses = NULL;
105   do_if->clause_cnt = 0;
106   do_if->ds = ds;
107
108   ctl_stack_push (&do_if_class, do_if);
109   add_transformation_with_finalizer (ds, do_if_finalize_func,
110                                      do_if_trns_proc, do_if_trns_free, do_if);
111
112   return parse_clause (lexer, do_if, ds);
113 }
114
115 /* Parse ELSE IF. */
116 int
117 cmd_else_if (struct lexer *lexer, struct dataset *ds)
118 {
119   struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
120   if (do_if == NULL || !must_not_have_else (do_if))
121     return CMD_CASCADING_FAILURE;
122   return parse_clause (lexer, do_if, ds);
123 }
124
125 /* Parse ELSE. */
126 int
127 cmd_else (struct lexer *lexer, struct dataset *ds)
128 {
129   struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
130   assert (ds == do_if->ds);
131   if (do_if == NULL || !must_not_have_else (do_if))
132     return CMD_CASCADING_FAILURE;
133   add_else (do_if);
134   return lex_end_of_command (lexer);
135 }
136
137 /* Parse END IF. */
138 int
139 cmd_end_if (struct lexer *lexer, struct dataset *ds)
140 {
141   struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
142   assert (ds == do_if->ds);
143
144   if (do_if == NULL)
145     return CMD_CASCADING_FAILURE;
146
147   ctl_stack_pop (do_if);
148
149   return lex_end_of_command (lexer);
150 }
151
152 /* Closes out DO_IF, by adding a sentinel ELSE clause if
153    necessary and setting past_END_IF_index. */
154 static void
155 close_do_if (void *do_if_)
156 {
157   struct do_if_trns *do_if = do_if_;
158   
159   if (!has_else (do_if)) 
160     add_else (do_if);
161   do_if->past_END_IF_index = next_transformation (do_if->ds);
162 }
163
164 /* Adds an ELSE clause to DO_IF pointing to the next
165    transformation. */
166 static void
167 add_else (struct do_if_trns *do_if) 
168 {
169   assert (!has_else (do_if));
170   add_clause (do_if, NULL, next_transformation (do_if->ds));
171 }
172
173 /* Returns true if DO_IF does not yet have an ELSE clause.
174    Reports an error and returns false if it does already. */
175 static bool
176 must_not_have_else (struct do_if_trns *do_if) 
177 {
178   if (has_else (do_if))
179     {
180       msg (SE, _("This command may not follow ELSE in DO IF...END IF."));
181       return false;
182     }
183   else
184     return true;
185 }
186
187 /* Returns true if DO_IF already has an ELSE clause,
188    false otherwise. */
189 static bool
190 has_else (struct do_if_trns *do_if) 
191 {
192   return (do_if->clause_cnt != 0
193           && do_if->clauses[do_if->clause_cnt - 1].condition == NULL);
194 }
195
196 /* Parses a DO IF or ELSE IF expression and appends the
197    corresponding clause to DO_IF.  Checks for end of command and
198    returns a command return code. */
199 static int
200 parse_clause (struct lexer *lexer, struct do_if_trns *do_if, struct dataset *ds)
201 {
202   struct expression *condition;
203
204   condition = expr_parse (lexer, ds, EXPR_BOOLEAN);
205   if (condition == NULL)
206     return CMD_CASCADING_FAILURE;
207
208   add_clause (do_if, condition, next_transformation (ds));
209
210   return lex_end_of_command (lexer);
211 }
212
213 /* Adds a clause to DO_IF that tests for the given CONDITION and,
214    if true, jumps to TARGET_INDEX. */
215 static void
216 add_clause (struct do_if_trns *do_if,
217             struct expression *condition, int target_index) 
218 {
219   struct clause *clause;
220
221   if (do_if->clause_cnt > 0)
222     add_transformation (do_if->ds, break_trns_proc, NULL, do_if);
223
224   do_if->clauses = xnrealloc (do_if->clauses,
225                               do_if->clause_cnt + 1, sizeof *do_if->clauses);
226   clause = &do_if->clauses[do_if->clause_cnt++];
227   clause->condition = condition;
228   clause->target_index = target_index;
229 }
230
231 /* Finalizes DO IF by clearing the control stack, thus ensuring
232    that all open DO IFs are closed. */ 
233 static void
234 do_if_finalize_func (void *do_if_ UNUSED) 
235 {
236   /* This will be called multiple times if multiple DO IFs were
237      executed, which is slightly unclean, but at least it's
238      idempotent. */
239   ctl_stack_clear ();
240 }
241
242 /* DO IF transformation procedure.
243    Checks each clause and jumps to the appropriate
244    transformation. */
245 static int 
246 do_if_trns_proc (void *do_if_, struct ccase *c, casenumber case_num UNUSED)
247 {
248   struct do_if_trns *do_if = do_if_;
249   struct clause *clause;
250
251   for (clause = do_if->clauses; clause < do_if->clauses + do_if->clause_cnt;
252        clause++) 
253     {
254       if (clause->condition != NULL)
255         {
256           double boolean = expr_evaluate_num (clause->condition, c, case_num);
257           if (boolean == 1.0)
258             return clause->target_index;
259           else if (boolean == SYSMIS)
260             return do_if->past_END_IF_index;
261         }
262       else 
263         return clause->target_index;
264     }
265   return do_if->past_END_IF_index;
266 }
267
268 /* Frees a DO IF transformation. */
269 static bool
270 do_if_trns_free (void *do_if_)
271 {
272   struct do_if_trns *do_if = do_if_;
273   struct clause *clause;
274
275   for (clause = do_if->clauses; clause < do_if->clauses + do_if->clause_cnt;
276        clause++)
277     expr_free (clause->condition);
278   free (do_if->clauses);
279   free (do_if);
280   return true;
281 }
282
283 /* Breaks out of a DO IF construct. */
284 static int 
285 break_trns_proc (void *do_if_, struct ccase *c UNUSED, casenumber case_num UNUSED)
286 {
287   struct do_if_trns *do_if = do_if_;
288
289   return do_if->past_END_IF_index;
290 }
291
292 /* DO IF control structure class definition. */
293 static const struct ctl_class do_if_class = 
294   {
295     "DO IF",
296     "END IF",
297     close_do_if,
298   };