1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
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.
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.
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/>. */
19 #include "language/command.h"
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/text-item.h"
45 #define _(msgid) gettext (msgid)
46 #define N_(msgid) msgid
48 /* Returns true if RESULT is a valid "enum cmd_result",
51 cmd_result_is_valid (enum cmd_result result)
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);
59 /* Returns true if RESULT indicates success,
62 cmd_result_is_success (enum cmd_result result)
64 assert (cmd_result_is_valid (result));
68 /* Returns true if RESULT indicates failure,
71 cmd_result_is_failure (enum cmd_result result)
73 assert (cmd_result_is_valid (result));
77 /* Command processing states. */
80 S_INITIAL = 0x01, /* Allowed before active dataset defined. */
81 S_DATA = 0x02, /* Allowed after active dataset 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. */
87 /* Other command requirements. */
90 F_ENHANCED = 0x10, /* Allowed only in enhanced syntax mode. */
91 F_TESTING = 0x20, /* Allowed only in testing mode. */
92 F_ABBREV = 0x80 /* Not a candidate for name completion. */
95 /* A single command. */
98 enum states states; /* States in which command is allowed. */
99 enum flags flags; /* Other command requirements. */
100 const char *name; /* Command name. */
101 int (*function) (struct lexer *, struct dataset *); /* Function to call. */
104 /* Define the command array. */
105 #define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
106 #define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
107 static const struct command commands[] =
109 #include "command.def"
114 static const size_t command_cnt = sizeof commands / sizeof *commands;
116 static bool in_correct_state (const struct command *, enum cmd_state);
117 static bool report_state_mismatch (const struct command *, enum cmd_state);
118 static void set_completion_state (enum cmd_state);
120 /* Command parser. */
122 static const struct command *parse_command_name (struct lexer *,
124 static enum cmd_result do_parse_command (struct lexer *, struct dataset *, enum cmd_state);
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. */
130 cmd_parse_in_state (struct lexer *lexer, struct dataset *ds,
131 enum cmd_state state)
133 struct session *session = dataset_session (ds);
136 result = do_parse_command (lexer, ds, state);
138 ds = session_active_dataset (session);
139 assert (!proc_is_open (ds));
140 unset_cmd_algorithm ();
141 if (!dataset_end_of_command (ds))
142 result = CMD_CASCADING_FAILURE;
148 cmd_parse (struct lexer *lexer, struct dataset *ds)
150 const struct dictionary *dict = dataset_dict (ds);
151 return cmd_parse_in_state (lexer, ds,
152 dataset_has_source (ds) &&
153 dict_get_var_cnt (dict) > 0 ?
154 CMD_STATE_DATA : CMD_STATE_INITIAL);
158 /* Parses an entire command, from command name to terminating
160 static enum cmd_result
161 do_parse_command (struct lexer *lexer,
162 struct dataset *ds, enum cmd_state state)
164 const struct command *command = NULL;
165 enum cmd_result result;
169 /* Read the command's first token. */
170 set_completion_state (state);
171 if (lex_token (lexer) == T_STOP)
176 else if (lex_token (lexer) == T_ENDCMD)
178 /* Null commands can result from extra empty lines. */
179 result = CMD_SUCCESS;
183 /* Parse the command name. */
184 command = parse_command_name (lexer, &n_tokens);
187 result = CMD_FAILURE;
190 text_item_submit (text_item_create (TEXT_ITEM_COMMAND_OPEN, command->name));
193 if (command->function == NULL)
195 msg (SE, _("%s is not yet implemented."), command->name);
196 result = CMD_NOT_IMPLEMENTED;
198 else if ((command->flags & F_TESTING) && !settings_get_testing_mode ())
200 msg (SE, _("%s may be used only in testing mode."), command->name);
201 result = CMD_FAILURE;
203 else if ((command->flags & F_ENHANCED) && settings_get_syntax () != ENHANCED)
205 msg (SE, _("%s may be used only in enhanced syntax mode."),
207 result = CMD_FAILURE;
209 else if (!in_correct_state (command, state))
211 report_state_mismatch (command, state);
212 result = CMD_FAILURE;
216 /* Execute command. */
219 for (i = 0; i < n_tokens; i++)
221 result = command->function (lexer, ds);
224 assert (cmd_result_is_valid (result));
227 if (cmd_result_is_failure (result))
228 lex_interactive_reset (lexer);
229 else if (result == CMD_SUCCESS)
230 result = lex_end_of_command (lexer);
232 lex_discard_rest_of_command (lexer);
233 while (lex_token (lexer) == T_ENDCMD)
237 text_item_submit (text_item_create (TEXT_ITEM_COMMAND_CLOSE,
244 find_best_match (struct substring s, const struct command **matchp)
246 const struct command *cmd;
247 struct command_matcher cm;
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));
254 *matchp = command_matcher_get_match (&cm);
255 missing_words = command_matcher_get_missing_words (&cm);
257 command_matcher_destroy (&cm);
259 return missing_words;
263 parse_command_word (struct lexer *lexer, struct string *s, int n)
265 bool need_space = ds_last (s) != EOF && ds_last (s) != '-';
267 switch (lex_next_token (lexer, n))
270 ds_put_byte (s, '-');
275 ds_put_byte (s, ' ');
276 ds_put_cstr (s, lex_next_tokcstr (lexer, n));
280 if (lex_next_is_integer (lexer, n))
282 int integer = lex_next_integer (lexer, n);
286 ds_put_byte (s, ' ');
287 ds_put_format (s, "%ld", lex_next_integer (lexer, n));
298 /* Parses the command name. On success returns a pointer to the corresponding
299 struct command and stores the number of tokens in the command name into
300 *N_TOKENS. On failure, returns a null pointer and stores the number of
301 tokens required to determine that no command name was present into
303 static const struct command *
304 parse_command_name (struct lexer *lexer, int *n_tokens)
306 const struct command *command;
315 while (parse_command_word (lexer, &s, word))
317 missing_words = find_best_match (ds_ss (&s), &command);
318 if (missing_words <= 0)
323 if (command == NULL && missing_words > 0)
325 ds_put_cstr (&s, " .");
326 missing_words = find_best_match (ds_ss (&s), &command);
327 ds_truncate (&s, ds_length (&s) - 2);
332 if (ds_is_empty (&s))
333 lex_error (lexer, _("expecting command name"));
335 msg (SE, _("Unknown command `%s'."), ds_cstr (&s));
340 *n_tokens = (word + 1) + missing_words;
344 /* Returns true if COMMAND is allowed in STATE,
347 in_correct_state (const struct command *command, enum cmd_state state)
349 return ((state == CMD_STATE_INITIAL && command->states & S_INITIAL)
350 || (state == CMD_STATE_DATA && command->states & S_DATA)
351 || (state == CMD_STATE_INPUT_PROGRAM
352 && command->states & S_INPUT_PROGRAM)
353 || (state == CMD_STATE_FILE_TYPE && command->states & S_FILE_TYPE));
356 /* Emits an appropriate error message for trying to invoke
359 report_state_mismatch (const struct command *command, enum cmd_state state)
361 assert (!in_correct_state (command, state));
362 if (state == CMD_STATE_INITIAL || state == CMD_STATE_DATA)
364 switch ((int) command->states)
366 /* One allowed state. */
368 msg (SE, _("%s is allowed only before the active dataset has "
369 "been defined."), command->name);
372 msg (SE, _("%s is allowed only after the active dataset has "
373 "been defined."), command->name);
375 case S_INPUT_PROGRAM:
376 msg (SE, _("%s is allowed only inside INPUT PROGRAM."),
380 msg (SE, _("%s is allowed only inside FILE TYPE."), command->name);
383 /* Two allowed states. */
384 case S_INITIAL | S_DATA:
386 case S_INITIAL | S_INPUT_PROGRAM:
387 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
388 command->name, "INPUT PROGRAM");
390 case S_INITIAL | S_FILE_TYPE:
391 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
392 command->name, "FILE TYPE");
394 case S_DATA | S_INPUT_PROGRAM:
395 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
396 command->name, "INPUT PROGRAM");
398 case S_DATA | S_FILE_TYPE:
399 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
400 command->name, "FILE TYPE");
402 case S_INPUT_PROGRAM | S_FILE_TYPE:
403 msg (SE, _("%s is allowed only inside INPUT PROGRAM or inside FILE TYPE."), command->name);
406 /* Three allowed states. */
407 case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
408 msg (SE, _("%s is allowed only after the active dataset has "
409 "been defined, inside INPUT PROGRAM, or inside "
410 "FILE TYPE."), command->name);
412 case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
413 msg (SE, _("%s is allowed only before the active dataset has "
414 "been defined, inside INPUT PROGRAM, or inside "
415 "FILE TYPE."), command->name);
417 case S_INITIAL | S_DATA | S_FILE_TYPE:
419 case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
422 /* Four allowed states. */
423 case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
430 else if (state == CMD_STATE_INPUT_PROGRAM)
431 msg (SE, _("%s is not allowed inside %s."),
432 command->name, "INPUT PROGRAM" );
433 else if (state == CMD_STATE_FILE_TYPE)
434 msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
439 /* Command name completion. */
441 static enum cmd_state completion_state = CMD_STATE_INITIAL;
444 set_completion_state (enum cmd_state state)
446 completion_state = state;
449 /* Returns the next possible completion of a command name that
450 begins with PREFIX, in the current command state, or a null
451 pointer if no completions remain.
452 Before calling the first time, set *CMD to a null pointer. */
454 cmd_complete (const char *prefix, const struct command **cmd)
459 for (; *cmd < commands + command_cnt; (*cmd)++)
460 if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
461 && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
462 && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
463 && !((*cmd)->flags & F_ABBREV)
464 && ((*cmd)->function != NULL)
465 && in_correct_state (*cmd, completion_state))
466 return (*cmd)++->name;
471 /* Simple commands. */
473 /* Parse and execute FINISH command. */
475 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
480 /* Parses the N command. */
482 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
487 if (!lex_force_int (lexer))
489 x = lex_integer (lexer);
491 if (!lex_match_id (lexer, "ESTIMATED"))
492 dict_set_case_limit (dataset_dict (ds), x);
497 /* Parses, performs the EXECUTE procedure. */
499 cmd_execute (struct lexer *lexer UNUSED, struct dataset *ds)
501 bool ok = casereader_destroy (proc_open (ds));
502 if (!proc_commit (ds) || !ok)
503 return CMD_CASCADING_FAILURE;
507 /* Parses, performs the ERASE command. */
509 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
514 if (settings_get_safer_mode ())
516 msg (SE, _("This command not allowed when the SAFER option is set."));
520 if (!lex_force_match_id (lexer, "FILE"))
522 lex_match (lexer, T_EQUALS);
523 if (!lex_force_string (lexer))
526 filename = utf8_to_filename (lex_tokcstr (lexer));
527 retval = remove (filename);
532 msg (SW, _("Error removing `%s': %s."),
533 lex_tokcstr (lexer), strerror (errno));
541 /* Parses, performs the NEW FILE command. */
543 cmd_new_file (struct lexer *lexer UNUSED, struct dataset *ds)