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)
59 case CMD_NOT_IMPLEMENTED:
60 case CMD_CASCADING_FAILURE:
68 /* Returns true if RESULT indicates success,
71 cmd_result_is_success (enum cmd_result result)
73 assert (cmd_result_is_valid (result));
77 /* Returns true if RESULT indicates failure,
80 cmd_result_is_failure (enum cmd_result result)
82 assert (cmd_result_is_valid (result));
86 /* Command processing states. */
89 S_INITIAL = 1 << 0, /* Allowed before active dataset defined. */
90 S_DATA = 1 << 1, /* Allowed after active dataset defined. */
91 S_INPUT_PROGRAM = 1 << 2, /* Allowed in INPUT PROGRAM. */
92 S_FILE_TYPE = 1 << 3, /* Allowed in FILE TYPE. */
93 S_NESTED = 1 << 4, /* Allowed in LOOP and DO IF. */
95 S_ANY = S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE | S_NESTED,
98 /* Other command requirements. */
101 F_ENHANCED = 1 << 0, /* Allowed only in enhanced syntax mode. */
102 F_TESTING = 1 << 1, /* Allowed only in testing mode. */
103 F_ABBREV = 1 << 2 /* Not a candidate for name completion. */
106 /* A single command. */
109 enum states states; /* States in which command is allowed. */
110 enum flags flags; /* Other command requirements. */
111 const char *name; /* Command name. */
112 int (*function) (struct lexer *, struct dataset *); /* Function to call. */
115 /* Define the command array. */
116 #define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
117 #define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
118 static const struct command commands[] =
120 #include "command.def"
125 static const size_t n_commands = sizeof commands / sizeof *commands;
127 static bool in_correct_state (const struct command *, enum cmd_state);
128 static void report_state_mismatch (const struct command *, enum cmd_state);
129 static void set_completion_state (enum cmd_state);
131 /* Command parser. */
133 static const struct command *parse_command_name (struct lexer *,
135 static enum cmd_result do_parse_command (struct lexer *, struct dataset *, enum cmd_state);
137 /* Parses an entire command, from command name to terminating
138 dot. On failure, skips to the terminating dot.
139 Returns the command's success or failure result. */
141 cmd_parse_in_state (struct lexer *lexer, struct dataset *ds,
142 enum cmd_state state)
144 struct session *session = dataset_session (ds);
147 result = do_parse_command (lexer, ds, state);
149 ds = session_active_dataset (session);
150 assert (!proc_is_open (ds));
151 unset_cmd_algorithm ();
152 if (!dataset_end_of_command (ds))
153 result = CMD_CASCADING_FAILURE;
159 cmd_parse (struct lexer *lexer, struct dataset *ds)
161 const struct dictionary *dict = dataset_dict (ds);
162 return cmd_parse_in_state (lexer, ds,
163 dataset_has_source (ds) &&
164 dict_get_n_vars (dict) > 0 ?
165 CMD_STATE_DATA : CMD_STATE_INITIAL);
169 /* Parses an entire command, from command name to terminating
171 static enum cmd_result
172 do_parse_command (struct lexer *lexer,
173 struct dataset *ds, enum cmd_state state)
175 const struct command *command = NULL;
176 size_t nesting_level = SIZE_MAX;
177 enum cmd_result result;
180 /* Read the command's first token. */
181 set_completion_state (state);
182 if (lex_token (lexer) == T_STOP)
187 else if (lex_token (lexer) == T_ENDCMD)
189 /* Null commands can result from extra empty lines. */
190 result = CMD_SUCCESS;
194 /* Parse the command name. */
195 command = parse_command_name (lexer, &n_tokens);
198 result = CMD_FAILURE;
202 nesting_level = output_open_group (group_item_create_nocopy (
203 utf8_to_title (command->name),
204 utf8_to_title (command->name)));
206 if (command->function == NULL)
208 msg (SE, _("%s is not yet implemented."), command->name);
209 result = CMD_NOT_IMPLEMENTED;
211 else if ((command->flags & F_TESTING) && !settings_get_testing_mode ())
213 msg (SE, _("%s may be used only in testing mode."), command->name);
214 result = CMD_FAILURE;
216 else if ((command->flags & F_ENHANCED) && settings_get_syntax () != ENHANCED)
218 msg (SE, _("%s may be used only in enhanced syntax mode."),
220 result = CMD_FAILURE;
222 else if (!in_correct_state (command, state))
224 report_state_mismatch (command, state);
225 result = CMD_FAILURE;
229 /* Execute command. */
232 for (i = 0; i < n_tokens; i++)
234 result = command->function (lexer, ds);
237 assert (cmd_result_is_valid (result));
240 if (cmd_result_is_failure (result))
241 lex_interactive_reset (lexer);
242 else if (result == CMD_SUCCESS)
243 result = lex_end_of_command (lexer);
245 lex_discard_rest_of_command (lexer);
246 if (result != CMD_EOF && result != CMD_FINISH)
247 while (lex_token (lexer) == T_ENDCMD)
250 if (nesting_level != SIZE_MAX)
251 output_close_groups (nesting_level);
257 find_best_match (struct substring s, const struct command **matchp)
259 const struct command *cmd;
260 struct command_matcher cm;
263 command_matcher_init (&cm, s);
264 for (cmd = commands; cmd < &commands[n_commands]; cmd++)
265 command_matcher_add (&cm, ss_cstr (cmd->name), CONST_CAST (void *, cmd));
267 *matchp = command_matcher_get_match (&cm);
268 missing_words = command_matcher_get_missing_words (&cm);
270 command_matcher_destroy (&cm);
272 return missing_words;
276 parse_command_word (struct lexer *lexer, struct string *s, int n)
278 bool need_space = ds_last (s) != EOF && ds_last (s) != '-';
280 switch (lex_next_token (lexer, n))
283 ds_put_byte (s, '-');
288 ds_put_byte (s, ' ');
289 ds_put_cstr (s, lex_next_tokcstr (lexer, n));
293 if (lex_next_is_integer (lexer, n))
295 int integer = lex_next_integer (lexer, n);
299 ds_put_byte (s, ' ');
300 ds_put_format (s, "%ld", lex_next_integer (lexer, n));
311 /* Parses the command name. On success returns a pointer to the corresponding
312 struct command and stores the number of tokens in the command name into
313 *N_TOKENS. On failure, returns a null pointer and stores the number of
314 tokens required to determine that no command name was present into
316 static const struct command *
317 parse_command_name (struct lexer *lexer, int *n_tokens)
319 const struct command *command;
328 while (parse_command_word (lexer, &s, word))
330 missing_words = find_best_match (ds_ss (&s), &command);
331 if (missing_words <= 0)
336 if (command == NULL && missing_words > 0)
338 ds_put_cstr (&s, " .");
339 missing_words = find_best_match (ds_ss (&s), &command);
340 ds_truncate (&s, ds_length (&s) - 2);
345 if (ds_is_empty (&s))
346 lex_error (lexer, _("expecting command name"));
348 msg (SE, _("Unknown command `%s'."), ds_cstr (&s));
353 *n_tokens = (word + 1) + missing_words;
357 /* Returns true if COMMAND is allowed in STATE,
360 in_correct_state (const struct command *command, enum cmd_state state)
364 case CMD_STATE_INITIAL:
365 return command->states & S_INITIAL;
368 return command->states & S_DATA;
370 case CMD_STATE_INPUT_PROGRAM:
371 return command->states & S_INPUT_PROGRAM;
373 case CMD_STATE_FILE_TYPE:
374 return command->states & S_FILE_TYPE;
376 case CMD_STATE_NESTED:
377 return command->states & S_NESTED;
384 /* Emits an appropriate error message for trying to invoke
387 report_state_mismatch (const struct command *command, enum cmd_state state)
389 assert (!in_correct_state (command, state));
393 case CMD_STATE_INITIAL:
395 switch ((int) command->states)
397 /* One allowed state. */
399 msg (SE, _("%s is allowed only before the active dataset has "
400 "been defined."), command->name);
403 msg (SE, _("%s is allowed only after the active dataset has "
404 "been defined."), command->name);
406 case S_INPUT_PROGRAM:
407 msg (SE, _("%s is allowed only inside %s."),
408 command->name, "INPUT PROGRAM");
411 msg (SE, _("%s is allowed only inside %s."), command->name, "FILE TYPE");
414 /* Two allowed states. */
415 case S_INITIAL | S_DATA:
417 case S_INITIAL | S_INPUT_PROGRAM:
418 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
419 command->name, "INPUT PROGRAM");
421 case S_INITIAL | S_FILE_TYPE:
422 msg (SE, _("%s is allowed only before the active dataset has been defined or inside %s."),
423 command->name, "FILE TYPE");
425 case S_DATA | S_INPUT_PROGRAM:
426 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
427 command->name, "INPUT PROGRAM");
429 case S_DATA | S_FILE_TYPE:
430 msg (SE, _("%s is allowed only after the active dataset has been defined or inside %s."),
431 command->name, "FILE TYPE");
433 case S_INPUT_PROGRAM | S_FILE_TYPE:
434 msg (SE, _("%s is allowed only inside %s or inside %s."), command->name,
435 "INPUT PROGRAM", "FILE TYPE");
438 /* Three allowed states. */
439 case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
440 msg (SE, _("%s is allowed only after the active dataset has "
441 "been defined, inside INPUT PROGRAM, or inside "
442 "FILE TYPE."), command->name);
444 case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
445 msg (SE, _("%s is allowed only before the active dataset has "
446 "been defined, inside INPUT PROGRAM, or inside "
447 "FILE TYPE."), command->name);
449 case S_INITIAL | S_DATA | S_FILE_TYPE:
451 case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
454 /* Four allowed states. */
455 case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
463 case CMD_STATE_INPUT_PROGRAM:
464 msg (SE, _("%s is not allowed inside %s."),
465 command->name, "INPUT PROGRAM");
468 case CMD_STATE_FILE_TYPE:
469 msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
472 case CMD_STATE_NESTED:
473 msg (SE, _("%s is not allowed inside DO IF or LOOP."), command->name);
478 /* Command name completion. */
480 static enum cmd_state completion_state = CMD_STATE_INITIAL;
483 set_completion_state (enum cmd_state state)
485 completion_state = state;
488 /* Returns the next possible completion of a command name that
489 begins with PREFIX, in the current command state, or a null
490 pointer if no completions remain.
491 Before calling the first time, set *CMD to a null pointer. */
493 cmd_complete (const char *prefix, const struct command **cmd)
498 for (; *cmd < commands + n_commands; (*cmd)++)
499 if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
500 && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
501 && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
502 && !((*cmd)->flags & F_ABBREV)
503 && ((*cmd)->function != NULL)
504 && in_correct_state (*cmd, completion_state))
505 return (*cmd)++->name;
510 /* Simple commands. */
512 /* Parse and execute FINISH command. */
514 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
519 /* Parses the N command. */
521 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
523 if (!lex_force_int_range (lexer, "N OF CASES", 1, LONG_MAX))
525 long n = lex_integer (lexer);
527 if (!lex_match_id (lexer, "ESTIMATED"))
528 dict_set_case_limit (dataset_dict (ds), n);
533 /* Parses, performs the EXECUTE procedure. */
535 cmd_execute (struct lexer *lexer UNUSED, struct dataset *ds)
537 bool ok = casereader_destroy (proc_open (ds));
538 if (!proc_commit (ds) || !ok)
539 return CMD_CASCADING_FAILURE;
543 /* Parses, performs the ERASE command. */
545 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
550 if (settings_get_safer_mode ())
552 msg (SE, _("This command not allowed when the %s option is set."), "SAFER");
556 if (!lex_force_match_id (lexer, "FILE"))
558 lex_match (lexer, T_EQUALS);
559 if (!lex_force_string (lexer))
562 filename = utf8_to_filename (lex_tokcstr (lexer));
563 retval = remove (filename);
568 msg (SW, _("Error removing `%s': %s."),
569 lex_tokcstr (lexer), strerror (errno));
577 /* Parses, performs the NEW FILE command. */
579 cmd_new_file (struct lexer *lexer UNUSED, struct dataset *ds)