471c411850d30ac01e5b274656a98d04564dfd93
[pspp] / src / language / expressions / evaluate.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000, 2006 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 #include "private.h"
21
22 #include <ctype.h>
23 #include <libpspp/alloc.h>
24 #include <libpspp/assertion.h>
25 #include <libpspp/message.h>
26 #include "helpers.h"
27 #include "evaluate.h"
28 #include <libpspp/pool.h>
29
30 static void
31 expr_evaluate (struct expression *e, const struct ccase *c, int case_idx,
32                void *result)
33 {
34   struct dataset *ds = e->ds;
35   union operation_data *op = e->ops;
36
37   double *ns = e->number_stack;
38   struct substring *ss = e->string_stack;
39
40   /* Without a dictionary/dataset, the expression can't refer to variables, 
41      and you don't need to specify a case when you evaluate the
42      expression.  With a dictionary/dataset, the expression can refer
43      to variables, so you must specify a case when you evaluate the
44      expression. */
45   assert ((c != NULL) == (e->ds != NULL));
46
47   pool_clear (e->eval_pool);
48
49   for (;;)
50     {
51       assert (op < e->ops + e->op_cnt);
52       switch (op++->operation)
53         {
54         case OP_number:
55         case OP_boolean:
56           *ns++ = op++->number;
57           break;
58
59         case OP_string:
60           {
61             const struct substring *s = &op++->string;
62             *ss++ = copy_string (e, s->string, s->length);
63           }
64           break;
65
66         case OP_return_number:
67           *(double *) result = finite (ns[-1]) ? ns[-1] : SYSMIS;
68           return;
69
70         case OP_return_string:
71           *(struct substring *) result = ss[-1];
72           return;
73
74 #include "evaluate.inc"
75           
76         default:
77           NOT_REACHED ();
78         }
79     }
80 }
81
82 double
83 expr_evaluate_num (struct expression *e, const struct ccase *c, int case_idx)
84 {
85   double d;
86
87   assert (e->type == OP_number || e->type == OP_boolean);
88   expr_evaluate (e, c, case_idx, &d);
89   return d;
90 }
91
92 void
93 expr_evaluate_str (struct expression *e, const struct ccase *c, int case_idx,
94                    char *dst, size_t dst_size) 
95 {
96   struct substring s;
97
98   assert (e->type == OP_string);
99   assert ((dst == NULL) == (dst_size == 0));
100   expr_evaluate (e, c, case_idx, &s);
101   
102   buf_copy_rpad (dst, dst_size, s.string, s.length);
103 }
104 \f
105 #include <language/lexer/lexer.h>
106 #include <language/command.h>
107
108 int
109 cmd_debug_evaluate (struct lexer *lexer, struct dataset *dsother UNUSED)
110 {
111   bool optimize = true;
112   int retval = CMD_FAILURE;
113   bool dump_postfix = false;
114
115   struct ccase *c = NULL;
116
117   struct dataset *ds = NULL;
118
119   struct expression *expr;
120
121   for (;;) 
122     {
123       struct dictionary *d = NULL;
124       if (lex_match_id (lexer, "NOOPTIMIZE"))
125         optimize = 0;
126       else if (lex_match_id (lexer, "POSTFIX"))
127         dump_postfix = 1;
128       else if (lex_match (lexer, '('))
129         {
130           char name[LONG_NAME_LEN + 1];
131           struct variable *v;
132           size_t old_value_cnt;
133           int width;
134
135           if (!lex_force_id (lexer))
136             goto done;
137           strcpy (name, lex_tokid (lexer));
138
139           lex_get (lexer);
140           if (!lex_force_match (lexer, '='))
141             goto done;
142
143           if (lex_is_number (lexer))
144             {
145               width = 0;
146               fprintf (stderr, "(%s = %.2f)", name, lex_tokval (lexer)); 
147             }
148           else if (lex_token (lexer) == T_STRING) 
149             {
150               width = ds_length (lex_tokstr (lexer));
151               fprintf (stderr, "(%s = \"%.2s\")", name, ds_cstr (lex_tokstr (lexer))); 
152             }
153           else
154             {
155               lex_error (lexer, _("expecting number or string"));
156               goto done;
157             }
158           
159           if  ( ds == NULL ) 
160             {
161               ds = create_dataset ();
162               d = dataset_dict (ds);
163             }
164           
165           old_value_cnt = dict_get_next_value_idx (d);
166           v = dict_create_var (d, name, width);
167           if (v == NULL)
168             {
169               msg (SE, _("Duplicate variable name %s."), name);
170               goto done;
171             }
172
173           if (c == NULL) 
174             {
175               c = xmalloc (sizeof *c);
176               case_create (c, dict_get_next_value_idx (d));
177             }
178           else
179             case_resize (c, old_value_cnt, dict_get_next_value_idx (d));
180
181           if (lex_is_number (lexer))
182             case_data_rw (c, v)->f = lex_tokval (lexer);
183           else
184             memcpy (case_data_rw (c, v)->s, ds_data (lex_tokstr (lexer)),
185                     var_get_width (v));
186           lex_get (lexer);
187
188           if (!lex_force_match (lexer, ')'))
189             goto done;
190         }
191       else 
192         break;
193     }
194   if (lex_token (lexer) != '/') 
195     {
196       lex_force_match (lexer, '/');
197       goto done;
198     }
199
200   if ( ds != NULL ) 
201     fprintf(stderr, "; ");
202   fprintf (stderr, "%s => ", lex_rest_of_line (lexer, NULL));
203   lex_get (lexer);
204
205   expr = expr_parse_any (lexer, ds, optimize);
206   if (!expr || lex_end_of_command (lexer) != CMD_SUCCESS)
207     {
208       if (expr != NULL)
209         expr_free (expr);
210       fprintf (stderr, "error\n");
211       goto done;
212     }
213
214   if (dump_postfix) 
215     expr_debug_print_postfix (expr);
216   else 
217     switch (expr->type) 
218       {
219       case OP_number: 
220         {
221           double d = expr_evaluate_num (expr, c, 0);
222           if (d == SYSMIS)
223             fprintf (stderr, "sysmis\n");
224           else
225             fprintf (stderr, "%.2f\n", d); 
226         }
227         break;
228       
229       case OP_boolean: 
230         {
231           double b = expr_evaluate_num (expr, c, 0);
232           fprintf (stderr, "%s\n",
233                    b == SYSMIS ? "sysmis" : b == 0.0 ? "false" : "true"); 
234         }
235         break;
236
237       case OP_string: 
238         {
239           struct substring s;
240           expr_evaluate (expr, c, 0, &s);
241
242           fputc ('"', stderr);
243           fwrite (s.string, s.length, 1, stderr);
244           fputs ("\"\n", stderr);
245           break; 
246         }
247
248       default:
249         NOT_REACHED ();
250       }
251
252   expr_free (expr);
253   retval = CMD_SUCCESS;
254
255  done:
256   if (ds)
257     destroy_dataset (ds);
258
259   if (c != NULL) 
260     {
261       case_destroy (c);
262       free (c); 
263     }
264
265   return retval;
266 }
267
268 void
269 expr_debug_print_postfix (const struct expression *e) 
270 {
271   size_t i;
272
273   for (i = 0; i < e->op_cnt; i++) 
274     {
275       union operation_data *op = &e->ops[i];
276       if (i > 0)
277         putc (' ', stderr);
278       switch (e->op_types[i]) 
279         {
280         case OP_operation:
281           if (op->operation == OP_return_number)
282             fprintf (stderr, "return_number");
283           else if (op->operation == OP_return_string)
284             fprintf (stderr, "return_string");
285           else if (is_function (op->operation)) 
286             fprintf (stderr, "%s", operations[op->operation].prototype);
287           else if (is_composite (op->operation)) 
288             fprintf (stderr, "%s", operations[op->operation].name);
289           else
290             fprintf (stderr, "%s:", operations[op->operation].name);
291           break;
292         case OP_number:
293           if (op->number != SYSMIS)
294             fprintf (stderr, "n<%g>", op->number);
295           else
296             fprintf (stderr, "n<SYSMIS>");
297           break;
298         case OP_string:
299           fprintf (stderr, "s<%.*s>",
300                    (int) op->string.length,
301                    op->string.string != NULL ? op->string.string : "");
302           break;
303         case OP_format:
304           {
305             char str[FMT_STRING_LEN_MAX + 1];
306             fmt_to_string (op->format, str);
307             fprintf (stderr, "f<%s>", str); 
308           }
309           break;
310         case OP_variable:
311           fprintf (stderr, "v<%s>", var_get_name (op->variable));
312           break;
313         case OP_vector:
314           fprintf (stderr, "vec<%s>", vector_get_name (op->vector));
315           break;
316         case OP_integer:
317           fprintf (stderr, "i<%d>", op->integer);
318           break;
319         default:
320           NOT_REACHED ();
321         } 
322     }
323   fprintf (stderr, "\n");
324 }