Remove julcal.
[pspp] / src / do-if.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 #include <config.h>
21 #include "do-ifP.h"
22 #include "error.h"
23 #include <stdlib.h>
24 #include "alloc.h"
25 #include "command.h"
26 #include "error.h"
27 #include "expressions/public.h"
28 #include "lexer.h"
29 #include "str.h"
30 #include "var.h"
31
32 #include "debug-print.h"
33
34 /* *INDENT-OFF* */
35 /* Description of DO IF transformations:
36
37    DO IF has two transformations.  One is a conditional jump around
38    a false condition.  The second is an unconditional jump around
39    the rest of the code after a true condition.  Both of these types
40    have their destinations backpatched in by the next clause (ELSE IF,
41    END IF).
42
43    The characters `^V<>' are meant to represent arrows.
44
45    1. DO IF
46  V<<<<if false
47  V
48  V *. Transformations executed when the condition on DO IF is true.
49  V
50  V 2. GOTO>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>V
51  V                                                                     V
52  >>1. ELSE IF                                                          V
53  V<<<<if false                                                         V
54  V                                                                     V
55  V *. Transformations executed when condition on 1st ELSE IF is true.  V
56  V                                                                     V
57  V 2. GOTO>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>V
58  V                                                                     V
59  >>1. ELSE IF                                                          V
60  V<<<<if false                                                         V
61  V                                                                     V
62  V *. Transformations executed when condition on 2nd ELSE IF is true.  V
63  V                                                                     V
64  V 2. GOTO>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>V
65  V                                                                     V
66  >>*. Transformations executed when no condition is true. (ELSE)       V
67                                                                        V
68    *. Transformations after DO IF structure.<<<<<<<<<<<<<<<<<<<<<<<<<<<<
69
70 */
71 /* *INDENT-ON* */
72
73 static struct do_if_trns *parse_do_if (void);
74 static void add_ELSE_IF (struct do_if_trns *);
75 static trns_proc_func goto_trns_proc, do_if_trns_proc;
76 static trns_free_func do_if_trns_free;
77
78 /* Parse DO IF. */
79 int
80 cmd_do_if (void)
81 {
82   struct do_if_trns *t;
83
84   /* Parse the transformation. */
85   t = parse_do_if ();
86   if (!t)
87     return CMD_FAILURE;
88
89   /* Finish up the transformation, add to control stack, add to
90      transformation list. */
91   t->brk = NULL;
92   t->ctl.type = CST_DO_IF;
93   t->ctl.down = ctl_stack;
94   t->ctl.trns = (struct trns_header *) t;
95   t->ctl.brk = NULL;
96   t->has_else = 0;
97   ctl_stack = &t->ctl;
98   add_transformation ((struct trns_header *) t);
99
100   return CMD_SUCCESS;
101 }
102
103 /* Parse ELSE IF. */
104 int
105 cmd_else_if (void)
106 {
107   /* Transformation created. */
108   struct do_if_trns *t;
109
110   /* Check that we're in a pleasing situation. */
111   if (!ctl_stack || ctl_stack->type != CST_DO_IF)
112     {
113       msg (SE, _("There is no DO IF to match with this ELSE IF."));
114       return CMD_FAILURE;
115     }
116   if (((struct do_if_trns *) ctl_stack->trns)->has_else)
117     {
118       msg (SE, _("The ELSE command must follow all ELSE IF commands "
119                  "in a DO IF structure."));
120       return CMD_FAILURE;
121     }
122
123   /* Parse the transformation. */
124   t = parse_do_if ();
125   if (!t)
126     return CMD_FAILURE;
127
128   /* Stick in the breakout transformation. */
129   t->brk = xmalloc (sizeof *t->brk);
130   t->brk->h.proc = goto_trns_proc;
131   t->brk->h.free = NULL;
132
133   /* Add to list of transformations, add to string of ELSE IFs. */
134   add_transformation ((struct trns_header *) t->brk);
135   add_transformation ((struct trns_header *) t);
136
137   add_ELSE_IF (t);
138
139   if (token != '.')
140     {
141       msg (SE, _("End of command expected."));
142       return CMD_TRAILING_GARBAGE;
143     }
144
145   return CMD_SUCCESS;
146 }
147
148 /* Parse ELSE. */
149 int
150 cmd_else (void)
151 {
152   struct do_if_trns *t;
153
154   /* Check that we're in a pleasing situation. */
155   if (!ctl_stack || ctl_stack->type != CST_DO_IF)
156     {
157       msg (SE, _("There is no DO IF to match with this ELSE."));
158       return CMD_FAILURE;
159     }
160   
161   if (((struct do_if_trns *) ctl_stack->trns)->has_else)
162     {
163       msg (SE, _("There may be at most one ELSE clause in each DO IF "
164                  "structure.  It must be the last clause."));
165       return CMD_FAILURE;
166     }
167
168   /* Note that the ELSE transformation is *not* added to the list of
169      transformations.  That's because it doesn't need to do anything.
170      Its goto transformation *is* added, because that's necessary.
171      The main DO IF do_if_trns is the destructor for this ELSE
172      do_if_trns. */
173   t = xmalloc (sizeof *t);
174   t->next = NULL;
175   t->brk = xmalloc (sizeof *t->brk);
176   t->brk->h.proc = goto_trns_proc;
177   t->brk->h.free = NULL;
178   t->cond = NULL;
179   add_transformation ((struct trns_header *) t->brk);
180   t->h.index = t->brk->h.index + 1;
181
182   /* Add to string of ELSE IFs. */
183   add_ELSE_IF (t);
184
185   return lex_end_of_command ();
186 }
187
188 /* Parse END IF. */
189 int
190 cmd_end_if (void)
191 {
192   /* List iterator. */
193   struct do_if_trns *iter;
194
195   /* Check that we're in a pleasing situation. */
196   if (!ctl_stack || ctl_stack->type != CST_DO_IF)
197     {
198       msg (SE, _("There is no DO IF to match with this END IF."));
199       return CMD_FAILURE;
200     }
201
202   /* Chain down the list, backpatching destinations for gotos. */
203   iter = (struct do_if_trns *) ctl_stack->trns;
204   for (;;)
205     {
206       if (iter->brk)
207         iter->brk->dest = n_trns;
208       iter->missing_jump = n_trns;
209       if (iter->next)
210         iter = iter->next;
211       else
212         break;
213     }
214   iter->false_jump = n_trns;
215
216   /* Pop control stack. */
217   ctl_stack = ctl_stack->down;
218
219   return lex_end_of_command ();
220 }
221
222 /* Adds an ELSE IF or ELSE to the chain of them that hangs off the
223    main DO IF. */
224 static void
225 add_ELSE_IF (struct do_if_trns * t)
226 {
227   /* List iterator. */
228   struct do_if_trns *iter;
229
230   iter = (struct do_if_trns *) ctl_stack->trns;
231   while (iter->next)
232     iter = iter->next;
233   assert (iter != NULL);
234
235   iter->next = t;
236   iter->false_jump = t->h.index;
237 }
238
239 /* Parses a DO IF or ELSE IF command and returns a pointer to a mostly
240    filled in transformation. */
241 static struct do_if_trns *
242 parse_do_if (void)
243 {
244   struct do_if_trns *t;
245   struct expression *e;
246
247   e = expr_parse (default_dict, EXPR_BOOLEAN);
248   if (!e)
249     return NULL;
250   if (token != '.')
251     {
252       expr_free (e);
253       lex_error (_("expecting end of command"));
254       return NULL;
255     }
256
257   t = xmalloc (sizeof *t);
258   t->h.proc = do_if_trns_proc;
259   t->h.free = do_if_trns_free;
260   t->next = NULL;
261   t->cond = e;
262
263   return t;
264 }
265
266 /* Executes a goto transformation. */
267 static int 
268 goto_trns_proc (struct trns_header * t, struct ccase * c UNUSED,
269                 int case_num UNUSED)
270 {
271   return ((struct goto_trns *) t)->dest;
272 }
273
274 static int 
275 do_if_trns_proc (struct trns_header * trns, struct ccase * c,
276                  int case_num UNUSED)
277 {
278   struct do_if_trns *t = (struct do_if_trns *) trns;
279   double boolean;
280
281   boolean = expr_evaluate_num (t->cond, c, case_num);
282   if (boolean == 1.0)
283     {
284       debug_printf ((_("DO IF %d: true\n"), t->h.index));
285       return -1;
286     }
287   else if (boolean == 0.0)
288     {
289       debug_printf ((_("DO IF %d: false\n"), t->h.index));
290       return t->false_jump;
291     }
292   else
293     {
294       debug_printf ((_("DO IF %d: missing\n"), t->h.index));
295       return t->missing_jump;
296     }
297 }
298
299 static void 
300 do_if_trns_free (struct trns_header * trns)
301 {
302   struct do_if_trns *t = (struct do_if_trns *) trns;
303   expr_free (t->cond);
304
305   /* If brk is NULL then this is the main DO IF; therefore we
306      need to chain down to the ELSE and delete it. */
307   if (t->brk == NULL)
308     {
309       struct do_if_trns *iter = t->next;
310       while (iter)
311         {
312           if (!iter->cond)
313             {
314               /* This is the ELSE. */
315               free (iter);
316               break;
317             }
318           iter = iter->next;
319         }
320     }
321 }