1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012, 2013, 2014 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/driver.h"
40 #include "output/output-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)
62 case CMD_NOT_IMPLEMENTED:
63 case CMD_CASCADING_FAILURE:
71 /* Returns true if RESULT indicates success,
74 cmd_result_is_success (enum cmd_result result)
76 assert (cmd_result_is_valid (result));
80 /* Returns true if RESULT indicates failure,
83 cmd_result_is_failure (enum cmd_result result)
85 assert (cmd_result_is_valid (result));
89 /* Command processing states. */
92 S_INITIAL = 0x01, /* Allowed before active dataset defined. */
93 S_DATA = 0x02, /* Allowed after active dataset defined. */
94 S_INPUT_PROGRAM = 0x04, /* Allowed in INPUT PROGRAM. */
95 S_FILE_TYPE = 0x08, /* Allowed in FILE TYPE. */
96 S_ANY = 0x0f /* Allowed anywhere. */
99 /* Other command requirements. */
102 F_ENHANCED = 0x10, /* Allowed only in enhanced syntax mode. */
103 F_TESTING = 0x20, /* Allowed only in testing mode. */
104 F_ABBREV = 0x80 /* Not a candidate for name completion. */
107 /* A single command. */
110 enum states states; /* States in which command is allowed. */
111 enum flags flags; /* Other command requirements. */
112 const char *name; /* Command name. */
113 int (*function) (struct lexer *, struct dataset *); /* Function to call. */
116 /* Define the command array. */
117 #define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
118 #define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
119 static const struct command commands[] =
121 #include "command.def"
126 static const size_t command_cnt = sizeof commands / sizeof *commands;
128 static bool in_correct_state (const struct command *, enum cmd_state);
129 static bool report_state_mismatch (const struct command *, enum cmd_state);
130 static void set_completion_state (enum cmd_state);
132 /* Command parser. */
134 static const struct command *parse_command_name (struct lexer *,
136 static enum cmd_result do_parse_command (struct lexer *, struct dataset *, enum cmd_state);
138 /* Parses an entire command, from command name to terminating
139 dot. On failure, skips to the terminating dot.
140 Returns the command's success or failure result. */
142 cmd_parse_in_state (struct lexer *lexer, struct dataset *ds,
143 enum cmd_state state)
145 struct session *session = dataset_session (ds);
148 result = do_parse_command (lexer, ds, state);
150 ds = session_active_dataset (session);
151 assert (!proc_is_open (ds));
152 unset_cmd_algorithm ();
153 if (!dataset_end_of_command (ds))
154 result = CMD_CASCADING_FAILURE;
160 cmd_parse (struct lexer *lexer, struct dataset *ds)
162 const struct dictionary *dict = dataset_dict (ds);
163 return cmd_parse_in_state (lexer, ds,
164 dataset_has_source (ds) &&
165 dict_get_var_cnt (dict) > 0 ?
166 CMD_STATE_DATA : CMD_STATE_INITIAL);
170 /* Parses an entire command, from command name to terminating
172 static enum cmd_result
173 do_parse_command (struct lexer *lexer,
174 struct dataset *ds, enum cmd_state state)
176 const struct command *command = NULL;
177 size_t nesting_level = SIZE_MAX;
178 enum cmd_result result;
181 /* Read the command's first token. */
182 set_completion_state (state);
183 if (lex_token (lexer) == T_STOP)
188 else if (lex_token (lexer) == T_ENDCMD)
190 /* Null commands can result from extra empty lines. */
191 result = CMD_SUCCESS;
195 /* Parse the command name. */
196 command = parse_command_name (lexer, &n_tokens);
199 result = CMD_FAILURE;
203 nesting_level = output_open_group (group_item_create_nocopy (
204 utf8_to_title (command->name),
205 utf8_to_title (command->name)));
207 if (command->function == NULL)
209 msg (SE, _("%s is not yet implemented."), command->name);
210 result = CMD_NOT_IMPLEMENTED;
212 else if ((command->flags & F_TESTING) && !settings_get_testing_mode ())
214 msg (SE, _("%s may be used only in testing mode."), command->name);
215 result = CMD_FAILURE;
217 else if ((command->flags & F_ENHANCED) && settings_get_syntax () != ENHANCED)
219 msg (SE, _("%s may be used only in enhanced syntax mode."),
221 result = CMD_FAILURE;
223 else if (!in_correct_state (command, state))
225 report_state_mismatch (command, state);
226 result = CMD_FAILURE;
230 /* Execute command. */
233 for (i = 0; i < n_tokens; i++)
235 result = command->function (lexer, ds);
238 assert (cmd_result_is_valid (result));
241 if (cmd_result_is_failure (result))
242 lex_interactive_reset (lexer);
243 else if (result == CMD_SUCCESS)
244 result = lex_end_of_command (lexer);
246 lex_discard_rest_of_command (lexer);
247 if (result != CMD_EOF && result != CMD_FINISH)
248 while (lex_token (lexer) == T_ENDCMD)
251 if (nesting_level != SIZE_MAX)
252 output_close_groups (nesting_level);
258 find_best_match (struct substring s, const struct command **matchp)
260 const struct command *cmd;
261 struct command_matcher cm;
264 command_matcher_init (&cm, s);
265 for (cmd = commands; cmd < &commands[command_cnt]; cmd++)
266 command_matcher_add (&cm, ss_cstr (cmd->name), CONST_CAST (void *, cmd));
268 *matchp = command_matcher_get_match (&cm);
269 missing_words = command_matcher_get_missing_words (&cm);
271 command_matcher_destroy (&cm);
273 return missing_words;
277 parse_command_word (struct lexer *lexer, struct string *s, int n)
279 bool need_space = ds_last (s) != EOF && ds_last (s) != '-';
281 switch (lex_next_token (lexer, n))
284 ds_put_byte (s, '-');
289 ds_put_byte (s, ' ');
290 ds_put_cstr (s, lex_next_tokcstr (lexer, n));
294 if (lex_next_is_integer (lexer, n))
296 int integer = lex_next_integer (lexer, n);
300 ds_put_byte (s, ' ');
301 ds_put_format (s, "%ld", lex_next_integer (lexer, n));
312 /* Parses the command name. On success returns a pointer to the corresponding
313 struct command and stores the number of tokens in the command name into
314 *N_TOKENS. On failure, returns a null pointer and stores the number of
315 tokens required to determine that no command name was present into
317 static const struct command *
318 parse_command_name (struct lexer *lexer, int *n_tokens)
320 const struct command *command;
329 while (parse_command_word (lexer, &s, word))
331 missing_words = find_best_match (ds_ss (&s), &command);
332 if (missing_words <= 0)
337 if (command == NULL && missing_words > 0)
339 ds_put_cstr (&s, " .");
340 missing_words = find_best_match (ds_ss (&s), &command);
341 ds_truncate (&s, ds_length (&s) - 2);
346 if (ds_is_empty (&s))
347 lex_error (lexer, _("expecting command name"));
349 msg (SE, _("Unknown command `%s'."), ds_cstr (&s));
354 *n_tokens = (word + 1) + missing_words;
358 /* Returns true if COMMAND is allowed in STATE,
361 in_correct_state (const struct command *command, enum cmd_state state)
363 return ((state == CMD_STATE_INITIAL && command->states & S_INITIAL)
364 || (state == CMD_STATE_DATA && command->states & S_DATA)
365 || (state == CMD_STATE_INPUT_PROGRAM
366 && command->states & S_INPUT_PROGRAM)
367 || (state == CMD_STATE_FILE_TYPE && command->states & S_FILE_TYPE));
370 /* Emits an appropriate error message for trying to invoke
373 report_state_mismatch (const struct command *command, enum cmd_state state)
375 assert (!in_correct_state (command, state));
376 if (state == CMD_STATE_INITIAL || state == CMD_STATE_DATA)
378 switch ((int) command->states)
380 /* One allowed state. */
382 msg (SE, _("%s is allowed only before the active dataset has "
383 "been defined."), command->name);
386 msg (SE, _("%s is allowed only after the active dataset has "
387 "been defined."), command->name);
389 case S_INPUT_PROGRAM:
390 msg (SE, _("%s is allowed only inside %s."),
391 command->name, "INPUT PROGRAM");
394 msg (SE, _("%s is allowed only inside %s."), command->name, "FILE TYPE");
397 /* Two allowed states. */
398 case S_INITIAL | S_DATA:
400 case S_INITIAL | S_INPUT_PROGRAM:
401 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
402 command->name, "INPUT PROGRAM");
404 case S_INITIAL | S_FILE_TYPE:
405 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
406 command->name, "FILE TYPE");
408 case S_DATA | S_INPUT_PROGRAM:
409 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
410 command->name, "INPUT PROGRAM");
412 case S_DATA | S_FILE_TYPE:
413 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
414 command->name, "FILE TYPE");
416 case S_INPUT_PROGRAM | S_FILE_TYPE:
417 msg (SE, _("%s is allowed only inside %s or inside %s."), command->name,
418 "INPUT PROGRAM", "FILE TYPE");
421 /* Three allowed states. */
422 case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
423 msg (SE, _("%s is allowed only after the active dataset has "
424 "been defined, inside INPUT PROGRAM, or inside "
425 "FILE TYPE."), command->name);
427 case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
428 msg (SE, _("%s is allowed only before the active dataset has "
429 "been defined, inside INPUT PROGRAM, or inside "
430 "FILE TYPE."), command->name);
432 case S_INITIAL | S_DATA | S_FILE_TYPE:
434 case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
437 /* Four allowed states. */
438 case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
445 else if (state == CMD_STATE_INPUT_PROGRAM)
446 msg (SE, _("%s is not allowed inside %s."),
447 command->name, "INPUT PROGRAM");
448 else if (state == CMD_STATE_FILE_TYPE)
449 msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
454 /* Command name completion. */
456 static enum cmd_state completion_state = CMD_STATE_INITIAL;
459 set_completion_state (enum cmd_state state)
461 completion_state = state;
464 /* Returns the next possible completion of a command name that
465 begins with PREFIX, in the current command state, or a null
466 pointer if no completions remain.
467 Before calling the first time, set *CMD to a null pointer. */
469 cmd_complete (const char *prefix, const struct command **cmd)
474 for (; *cmd < commands + command_cnt; (*cmd)++)
475 if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
476 && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
477 && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
478 && !((*cmd)->flags & F_ABBREV)
479 && ((*cmd)->function != NULL)
480 && in_correct_state (*cmd, completion_state))
481 return (*cmd)++->name;
486 /* Simple commands. */
488 /* Parse and execute FINISH command. */
490 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
495 /* Parses the N command. */
497 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
499 if (!lex_force_int_range (lexer, "N OF CASES", 1, LONG_MAX))
501 long n = lex_integer (lexer);
503 if (!lex_match_id (lexer, "ESTIMATED"))
504 dict_set_case_limit (dataset_dict (ds), n);
509 /* Parses, performs the EXECUTE procedure. */
511 cmd_execute (struct lexer *lexer UNUSED, struct dataset *ds)
513 bool ok = casereader_destroy (proc_open (ds));
514 if (!proc_commit (ds) || !ok)
515 return CMD_CASCADING_FAILURE;
519 /* Parses, performs the ERASE command. */
521 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
526 if (settings_get_safer_mode ())
528 msg (SE, _("This command not allowed when the %s option is set."), "SAFER");
532 if (!lex_force_match_id (lexer, "FILE"))
534 lex_match (lexer, T_EQUALS);
535 if (!lex_force_string (lexer))
538 filename = utf8_to_filename (lex_tokcstr (lexer));
539 retval = remove (filename);
544 msg (SW, _("Error removing `%s': %s."),
545 lex_tokcstr (lexer), strerror (errno));
553 /* Parses, performs the NEW FILE command. */
555 cmd_new_file (struct lexer *lexer UNUSED, struct dataset *ds)