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