Rename var_array to nest.
[pspp] / src / language / command.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012, 2013, 2014 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 "language/command.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <ctype.h>
24 #include <errno.h>
25
26 #include "data/casereader.h"
27 #include "data/dataset.h"
28 #include "data/dictionary.h"
29 #include "data/session.h"
30 #include "data/settings.h"
31 #include "data/variable.h"
32 #include "language/lexer/command-name.h"
33 #include "language/lexer/lexer.h"
34 #include "libpspp/assertion.h"
35 #include "libpspp/compiler.h"
36 #include "libpspp/i18n.h"
37 #include "libpspp/message.h"
38 #include "libpspp/str.h"
39 #include "output/driver.h"
40 #include "output/output-item.h"
41
42 #include "xmalloca.h"
43
44 #include "gettext.h"
45 #define _(msgid) gettext (msgid)
46 #define N_(msgid) msgid
47 \f
48 /* Returns true if RESULT is a valid "enum cmd_result",
49    false otherwise. */
50 static inline bool
51 cmd_result_is_valid (enum cmd_result result)
52 {
53   switch (result)
54     {
55     case CMD_SUCCESS:
56     case CMD_EOF:
57     case CMD_FINISH:
58     case CMD_FAILURE:
59     case CMD_NOT_IMPLEMENTED:
60     case CMD_CASCADING_FAILURE:
61       return true;
62
63     default:
64       return false;
65     }
66 }
67
68 /* Returns true if RESULT indicates success,
69    false otherwise. */
70 bool
71 cmd_result_is_success (enum cmd_result result)
72 {
73   assert (cmd_result_is_valid (result));
74   return result > 0;
75 }
76
77 /* Returns true if RESULT indicates failure,
78    false otherwise. */
79 bool
80 cmd_result_is_failure (enum cmd_result result)
81 {
82   assert (cmd_result_is_valid (result));
83   return result < 0;
84 }
85 \f
86 /* Command processing states. */
87 enum states
88   {
89     S_INITIAL = 1 << CMD_STATE_INITIAL,
90     S_DATA = 1 << CMD_STATE_DATA,
91     S_INPUT_PROGRAM = 1 << CMD_STATE_INPUT_PROGRAM,
92     S_FILE_TYPE = 1 << CMD_STATE_FILE_TYPE,
93     S_NESTED_DATA = 1 << CMD_STATE_NESTED_DATA,
94     S_NESTED_INPUT_PROGRAM = 1 << CMD_STATE_NESTED_INPUT_PROGRAM,
95
96     S_NESTED_ANY = S_NESTED_DATA | S_NESTED_INPUT_PROGRAM,
97     S_ANY = S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE | S_NESTED_ANY,
98   };
99
100 /* Other command requirements. */
101 enum flags
102   {
103     F_ENHANCED = 1 << 0,        /* Allowed only in enhanced syntax mode. */
104     F_TESTING = 1 << 1,         /* Allowed only in testing mode. */
105     F_ABBREV = 1 << 2           /* Not a candidate for name completion. */
106   };
107
108 /* A single command. */
109 struct command
110   {
111     enum states states;         /* States in which command is allowed. */
112     enum flags flags;           /* Other command requirements. */
113     const char *name;           /* Command name. */
114     int (*function) (struct lexer *, struct dataset *); /* Function to call. */
115   };
116
117 /* Define the command array. */
118 #define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
119 #define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
120 static const struct command commands[] =
121   {
122 #include "command.def"
123   };
124 #undef DEF_CMD
125 #undef UNIMPL_CMD
126
127 static const size_t n_commands = sizeof commands / sizeof *commands;
128
129 static bool in_correct_state (const struct command *, enum cmd_state);
130 static void report_state_mismatch (const struct command *, enum cmd_state);
131 static void set_completion_state (enum cmd_state);
132 \f
133 /* Command parser. */
134
135 static const struct command *parse_command_name (struct lexer *,
136                                                  int *n_tokens);
137 static enum cmd_result do_parse_command (struct lexer *, struct dataset *, enum cmd_state);
138
139 /* Parses an entire command, from command name to terminating
140    dot.  On failure, skips to the terminating dot.
141    Returns the command's success or failure result. */
142 enum cmd_result
143 cmd_parse_in_state (struct lexer *lexer, struct dataset *ds,
144                     enum cmd_state state)
145 {
146   struct session *session = dataset_session (ds);
147   int result;
148
149   result = do_parse_command (lexer, ds, state);
150
151   ds = session_active_dataset (session);
152   assert (!proc_is_open (ds));
153   unset_cmd_algorithm ();
154   if (!dataset_end_of_command (ds))
155     result = CMD_CASCADING_FAILURE;
156
157   return result;
158 }
159
160 enum cmd_result
161 cmd_parse (struct lexer *lexer, struct dataset *ds)
162 {
163   const struct dictionary *dict = dataset_dict (ds);
164   return cmd_parse_in_state (lexer, ds,
165                              dataset_has_source (ds) &&
166                              dict_get_n_vars (dict) > 0 ?
167                              CMD_STATE_DATA : CMD_STATE_INITIAL);
168 }
169
170
171 /* Parses an entire command, from command name to terminating
172    dot. */
173 static enum cmd_result
174 do_parse_command (struct lexer *lexer,
175                   struct dataset *ds, enum cmd_state state)
176 {
177   const struct command *command = NULL;
178   size_t nesting_level = SIZE_MAX;
179   enum cmd_result result;
180   int n_tokens;
181
182   /* Read the command's first token. */
183   set_completion_state (state);
184   if (lex_token (lexer) == T_STOP)
185     {
186       result = CMD_EOF;
187       goto finish;
188     }
189   else if (lex_token (lexer) == T_ENDCMD)
190     {
191       /* Null commands can result from extra empty lines. */
192       result = CMD_SUCCESS;
193       goto finish;
194     }
195
196   /* Parse the command name. */
197   command = parse_command_name (lexer, &n_tokens);
198   if (command == NULL)
199     {
200       result = CMD_FAILURE;
201       goto finish;
202     }
203
204   nesting_level = output_open_group (group_item_create_nocopy (
205                                        utf8_to_title (command->name),
206                                        utf8_to_title (command->name)));
207
208   if (command->function == NULL)
209     {
210       msg (SE, _("%s is not yet implemented."), command->name);
211       result = CMD_NOT_IMPLEMENTED;
212     }
213   else if ((command->flags & F_TESTING) && !settings_get_testing_mode ())
214     {
215       msg (SE, _("%s may be used only in testing mode."), command->name);
216       result = CMD_FAILURE;
217     }
218   else if ((command->flags & F_ENHANCED) && settings_get_syntax () != ENHANCED)
219     {
220       msg (SE, _("%s may be used only in enhanced syntax mode."),
221            command->name);
222       result = CMD_FAILURE;
223     }
224   else if (!in_correct_state (command, state))
225     {
226       report_state_mismatch (command, state);
227       result = CMD_FAILURE;
228     }
229   else
230     {
231       /* Execute command. */
232       int i;
233
234       for (i = 0; i < n_tokens; i++)
235         lex_get (lexer);
236       result = command->function (lexer, ds);
237     }
238
239   assert (cmd_result_is_valid (result));
240
241 finish:
242   if (cmd_result_is_failure (result))
243     lex_interactive_reset (lexer);
244   else if (result == CMD_SUCCESS)
245     result = lex_end_of_command (lexer);
246
247   lex_discard_rest_of_command (lexer);
248   if (result != CMD_EOF && result != CMD_FINISH)
249     while (lex_token (lexer) == T_ENDCMD)
250       lex_get (lexer);
251
252   if (nesting_level != SIZE_MAX)
253     output_close_groups (nesting_level);
254
255   return result;
256 }
257
258 static int
259 find_best_match (struct substring s, const struct command **matchp)
260 {
261   const struct command *cmd;
262   struct command_matcher cm;
263   int missing_words;
264
265   command_matcher_init (&cm, s);
266   for (cmd = commands; cmd < &commands[n_commands]; cmd++)
267     command_matcher_add (&cm, ss_cstr (cmd->name), CONST_CAST (void *, cmd));
268
269   *matchp = command_matcher_get_match (&cm);
270   missing_words = command_matcher_get_missing_words (&cm);
271
272   command_matcher_destroy (&cm);
273
274   return missing_words;
275 }
276
277 static bool
278 parse_command_word (struct lexer *lexer, struct string *s, int n)
279 {
280   bool need_space = ds_last (s) != EOF && ds_last (s) != '-';
281
282   switch (lex_next_token (lexer, n))
283     {
284     case T_DASH:
285       ds_put_byte (s, '-');
286       return true;
287
288     case T_ID:
289       if (need_space)
290         ds_put_byte (s, ' ');
291       ds_put_cstr (s, lex_next_tokcstr (lexer, n));
292       return true;
293
294     case T_POS_NUM:
295       if (lex_next_is_integer (lexer, n))
296         {
297           int integer = lex_next_integer (lexer, n);
298           if (integer >= 0)
299             {
300               if (need_space)
301                 ds_put_byte (s, ' ');
302               ds_put_format (s, "%ld", lex_next_integer (lexer, n));
303               return true;
304             }
305         }
306       return false;
307
308     default:
309       return false;
310     }
311 }
312
313 /* Parses the command name.  On success returns a pointer to the corresponding
314    struct command and stores the number of tokens in the command name into
315    *N_TOKENS.  On failure, returns a null pointer and stores the number of
316    tokens required to determine that no command name was present into
317    *N_TOKENS. */
318 static const struct command *
319 parse_command_name (struct lexer *lexer, int *n_tokens)
320 {
321   const struct command *command;
322   int missing_words;
323   struct string s;
324   int word;
325
326   command = NULL;
327   missing_words = 0;
328   ds_init_empty (&s);
329   word = 0;
330   while (parse_command_word (lexer, &s, word))
331     {
332       missing_words = find_best_match (ds_ss (&s), &command);
333       if (missing_words <= 0)
334         break;
335       word++;
336     }
337
338   if (command == NULL && missing_words > 0)
339     {
340       ds_put_cstr (&s, " .");
341       missing_words = find_best_match (ds_ss (&s), &command);
342       ds_truncate (&s, ds_length (&s) - 2);
343     }
344
345   if (command == NULL)
346     {
347       if (ds_is_empty (&s))
348         lex_error (lexer, _("expecting command name"));
349       else
350         msg (SE, _("Unknown command `%s'."), ds_cstr (&s));
351     }
352
353   ds_destroy (&s);
354
355   *n_tokens = (word + 1) + missing_words;
356   return command;
357 }
358
359 /* Returns true if COMMAND is allowed in STATE,
360    false otherwise. */
361 static bool
362 in_correct_state (const struct command *command, enum cmd_state state)
363 {
364   return command->states & (1 << state);
365 }
366
367 /* Emits an appropriate error message for trying to invoke
368    COMMAND in STATE. */
369 static void
370 report_state_mismatch (const struct command *command, enum cmd_state state)
371 {
372   assert (!in_correct_state (command, state));
373
374   switch (state)
375     {
376     case CMD_STATE_INITIAL:
377     case CMD_STATE_DATA:
378       switch ((int) command->states
379               & (S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE))
380         {
381           /* One allowed state. */
382         case S_INITIAL:
383           msg (SE, _("%s is allowed only before the active dataset has "
384                      "been defined."), command->name);
385           break;
386         case S_DATA:
387           msg (SE, _("%s is allowed only after the active dataset has "
388                      "been defined."), command->name);
389           break;
390         case S_INPUT_PROGRAM:
391           msg (SE, _("%s is allowed only inside %s."),
392                command->name, "INPUT PROGRAM");
393           break;
394         case S_FILE_TYPE:
395           msg (SE, _("%s is allowed only inside %s."), command->name, "FILE TYPE");
396           break;
397
398           /* Two allowed states. */
399         case S_INITIAL | S_DATA:
400           NOT_REACHED ();
401         case S_INITIAL | S_INPUT_PROGRAM:
402           msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
403                command->name, "INPUT PROGRAM");
404           break;
405         case S_INITIAL | S_FILE_TYPE:
406           msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
407                command->name, "FILE TYPE");
408           break;
409         case S_DATA | S_INPUT_PROGRAM:
410           msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
411                command->name, "INPUT PROGRAM");
412           break;
413         case S_DATA | S_FILE_TYPE:
414           msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
415                command->name, "FILE TYPE");
416           break;
417         case S_INPUT_PROGRAM | S_FILE_TYPE:
418           msg (SE, _("%s is allowed only inside %s or inside %s."), command->name,
419                "INPUT PROGRAM", "FILE TYPE");
420           break;
421
422           /* Three allowed states. */
423         case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
424           msg (SE, _("%s is allowed only after the active dataset has "
425                      "been defined, inside INPUT PROGRAM, or inside "
426                      "FILE TYPE."), command->name);
427           break;
428         case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
429           msg (SE, _("%s is allowed only before the active dataset has "
430                      "been defined, inside INPUT PROGRAM, or inside "
431                      "FILE TYPE."), command->name);
432           break;
433         case S_INITIAL | S_DATA | S_FILE_TYPE:
434           NOT_REACHED ();
435         case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
436           NOT_REACHED ();
437
438           /* Four allowed states. */
439         case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
440           NOT_REACHED ();
441
442         default:
443           NOT_REACHED ();
444         }
445       break;
446
447     case CMD_STATE_INPUT_PROGRAM:
448       msg (SE, _("%s is not allowed inside %s."),
449            command->name, "INPUT PROGRAM");
450       break;
451
452     case CMD_STATE_FILE_TYPE:
453       msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
454       break;
455
456     case CMD_STATE_NESTED_DATA:
457     case CMD_STATE_NESTED_INPUT_PROGRAM:
458       switch ((int) command->states & S_NESTED_ANY)
459         {
460         case 0:
461           msg (SE, _("%s is not allowed inside DO IF or LOOP."), command->name);
462           break;
463
464         case S_NESTED_DATA:
465           msg (SE, _("In INPUT PROGRAM, "
466                      "%s is not allowed inside DO IF or LOOP."), command->name);
467           break;
468
469         default:
470           NOT_REACHED ();
471         }
472       break;
473     }
474 }
475 \f
476 /* Command name completion. */
477
478 static enum cmd_state completion_state = CMD_STATE_INITIAL;
479
480 static void
481 set_completion_state (enum cmd_state state)
482 {
483   completion_state = state;
484 }
485
486 /* Returns the next possible completion of a command name that
487    begins with PREFIX, in the current command state, or a null
488    pointer if no completions remain.
489    Before calling the first time, set *CMD to a null pointer. */
490 const char *
491 cmd_complete (const char *prefix, const struct command **cmd)
492 {
493   if (*cmd == NULL)
494     *cmd = commands;
495
496   for (; *cmd < commands + n_commands; (*cmd)++)
497     if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
498         && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
499         && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
500         && !((*cmd)->flags & F_ABBREV)
501         && ((*cmd)->function != NULL)
502         && in_correct_state (*cmd, completion_state))
503       return (*cmd)++->name;
504
505   return NULL;
506 }
507 \f
508 /* Simple commands. */
509
510 /* Parse and execute FINISH command. */
511 int
512 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
513 {
514   return CMD_FINISH;
515 }
516
517 /* Parses the N command. */
518 int
519 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
520 {
521   if (!lex_force_int_range (lexer, "N OF CASES", 1, LONG_MAX))
522     return CMD_FAILURE;
523   long n = lex_integer (lexer);
524   lex_get (lexer);
525   if (!lex_match_id (lexer, "ESTIMATED"))
526     dict_set_case_limit (dataset_dict (ds), n);
527
528   return CMD_SUCCESS;
529 }
530
531 /* Parses, performs the EXECUTE procedure. */
532 int
533 cmd_execute (struct lexer *lexer UNUSED, struct dataset *ds)
534 {
535   bool ok = casereader_destroy (proc_open (ds));
536   if (!proc_commit (ds) || !ok)
537     return CMD_CASCADING_FAILURE;
538   return CMD_SUCCESS;
539 }
540
541 /* Parses, performs the ERASE command. */
542 int
543 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
544 {
545   char *filename;
546   int retval;
547
548   if (settings_get_safer_mode ())
549     {
550       msg (SE, _("This command not allowed when the %s option is set."), "SAFER");
551       return CMD_FAILURE;
552     }
553
554   if (!lex_force_match_id (lexer, "FILE"))
555     return CMD_FAILURE;
556   lex_match (lexer, T_EQUALS);
557   if (!lex_force_string (lexer))
558     return CMD_FAILURE;
559
560   filename = utf8_to_filename (lex_tokcstr (lexer));
561   retval = remove (filename);
562   free (filename);
563
564   if (retval == -1)
565     {
566       msg (SW, _("Error removing `%s': %s."),
567            lex_tokcstr (lexer), strerror (errno));
568       return CMD_FAILURE;
569     }
570   lex_get (lexer);
571
572   return CMD_SUCCESS;
573 }
574
575 /* Parses, performs the NEW FILE command. */
576 int
577 cmd_new_file (struct lexer *lexer UNUSED, struct dataset *ds)
578 {
579   dataset_clear (ds);
580   return CMD_SUCCESS;
581 }