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/case.h"
22 #include "data/dataset.h"
23 #include "data/transformations.h"
24 #include "data/value.h"
25 #include "language/command.h"
26 #include "language/control/control-stack.h"
27 #include "language/expressions/public.h"
28 #include "language/lexer/lexer.h"
29 #include "libpspp/compiler.h"
30 #include "libpspp/message.h"
31 #include "libpspp/str.h"
32
33 #include "gl/xalloc.h"
34
35 #include "gettext.h"
36 #define _(msgid) gettext (msgid)
37
38 /* DO IF, ELSE IF, and ELSE are translated as a single
39 transformation that evaluates each condition and jumps to the
40 start of the appropriate block of transformations. Each block
41 of transformations (except for the last) ends with a
42 transformation that jumps past the remaining blocks.
43
44 So, the following code:
45
46 DO IF a.
47 ...block 1...
48 ELSE IF b.
49 ...block 2...
50 ELSE.
51 ...block 3...
52 END IF.
53
54 is effectively translated like this:
55
56 IF a GOTO 1, IF b GOTO 2, ELSE GOTO 3.
57 1: ...block 1...
58 GOTO 4
59 2: ...block 2...
60 GOTO 4
61 3: ...block 3...
62 4:
63
64 */
65
66 /* A conditional clause. */
67 struct clause
68 {
69 struct expression *condition; /* Test expression; NULL for ELSE clause. */
70 int target_index; /* Transformation to jump to if true. */
71 };
72
73 /* DO IF transformation. */
74 struct do_if_trns
75 {
76 struct dataset *ds; /* The dataset */
77 struct clause *clauses; /* Clauses. */
78 size_t clause_cnt; /* Number of clauses. */
79 int past_END_IF_index; /* Transformation just past last clause. */
80 };
81
82 static const struct ctl_class do_if_class;
83
84 static int parse_clause (struct lexer *, struct do_if_trns *, struct dataset *ds);
85 static void add_clause (struct do_if_trns *, struct expression *condition);
86 static void add_else (struct do_if_trns *);
87
88 static bool has_else (struct do_if_trns *);
89 static bool must_not_have_else (struct do_if_trns *);
90 static void close_do_if (void *do_if);
91
92 static trns_finalize_func do_if_finalize_func;
93 static trns_proc_func do_if_trns_proc, break_trns_proc;
94 static trns_free_func do_if_trns_free;
95
96 /* Parse DO IF. */
97 int
cmd_do_if(struct lexer * lexer,struct dataset * ds)98 cmd_do_if (struct lexer *lexer, struct dataset *ds)
99 {
100 struct do_if_trns *do_if = xmalloc (sizeof *do_if);
101 do_if->clauses = NULL;
102 do_if->clause_cnt = 0;
103 do_if->ds = ds;
104
105 ctl_stack_push (&do_if_class, do_if);
106 add_transformation_with_finalizer (ds, do_if_finalize_func,
107 do_if_trns_proc, do_if_trns_free, do_if);
108
109 return parse_clause (lexer, do_if, ds);
110 }
111
112 /* Parse ELSE IF. */
113 int
cmd_else_if(struct lexer * lexer,struct dataset * ds)114 cmd_else_if (struct lexer *lexer, struct dataset *ds)
115 {
116 struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
117 if (do_if == NULL || !must_not_have_else (do_if))
118 return CMD_CASCADING_FAILURE;
119 return parse_clause (lexer, do_if, ds);
120 }
121
122 /* Parse ELSE. */
123 int
cmd_else(struct lexer * lexer UNUSED,struct dataset * ds)124 cmd_else (struct lexer *lexer UNUSED, struct dataset *ds)
125 {
126 struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
127
128 if (do_if == NULL || !must_not_have_else (do_if))
129 return CMD_CASCADING_FAILURE;
130
131 assert (ds == do_if->ds);
132
133 add_else (do_if);
134 return CMD_SUCCESS;
135 }
136
137 /* Parse END IF. */
138 int
cmd_end_if(struct lexer * lexer UNUSED,struct dataset * ds)139 cmd_end_if (struct lexer *lexer UNUSED, struct dataset *ds)
140 {
141 struct do_if_trns *do_if = ctl_stack_top (&do_if_class);
142
143 if (do_if == NULL)
144 return CMD_CASCADING_FAILURE;
145
146 assert (ds == do_if->ds);
147 ctl_stack_pop (do_if);
148
149 return CMD_SUCCESS;
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
close_do_if(void * do_if_)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
add_else(struct do_if_trns * do_if)167 add_else (struct do_if_trns *do_if)
168 {
169 assert (!has_else (do_if));
170 add_clause (do_if, NULL);
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
must_not_have_else(struct do_if_trns * do_if)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 %s in %s ... %s."), "ELSE", "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
has_else(struct do_if_trns * do_if)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
parse_clause(struct lexer * lexer,struct do_if_trns * do_if,struct dataset * ds)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);
209
210 return CMD_SUCCESS;
211 }
212
213 /* Adds a clause to DO_IF that tests for the given CONDITION and,
214 if true, jumps to the set of transformations produced by
215 following commands. */
216 static void
add_clause(struct do_if_trns * do_if,struct expression * condition)217 add_clause (struct do_if_trns *do_if, struct expression *condition)
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 = next_transformation (do_if->ds);
229 }
230
231 /* Finalizes DO IF by clearing the control stack, thus ensuring
232 that all open DO IFs are closed. */
233 static void
do_if_finalize_func(void * do_if_ UNUSED)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
do_if_trns_proc(void * do_if_,struct ccase ** c,casenumber case_num UNUSED)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
do_if_trns_free(void * do_if_)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
break_trns_proc(void * do_if_,struct ccase ** c UNUSED,casenumber case_num UNUSED)285 break_trns_proc (void *do_if_, struct ccase **c UNUSED,
286 casenumber case_num UNUSED)
287 {
288 struct do_if_trns *do_if = do_if_;
289
290 return do_if->past_END_IF_index;
291 }
292
293 /* DO IF control structure class definition. */
294 static const struct ctl_class do_if_class =
295 {
296 "DO IF",
297 "END IF",
298 close_do_if,
299 };
300