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/lexer.h"
  32 #include "language/prompt.h"
  33 #include "libpspp/assertion.h"
  34 #include "libpspp/compiler.h"
  35 #include "libpspp/message.h"
  36 #include "libpspp/str.h"
  37 #include "libpspp/getl.h"
  38 #include "output/text-item.h"
  39
  40 #include "xalloc.h"
  41 #include "xmalloca.h"
  42
  43 #include "gettext.h"
  44 #define _(msgid) gettext (msgid)
  45 #define N_(msgid) msgid
  46 \f
  47 /* Returns true if RESULT is a valid "enum cmd_result",
  48    false otherwise. */
  49 static inline bool
  50 cmd_result_is_valid (enum cmd_result result)
  51 {
  52   return (result == CMD_SUCCESS || result == CMD_EOF || result == CMD_FINISH
  53           || (result >= CMD_PRIVATE_FIRST && result <= CMD_PRIVATE_LAST)
  54           || result == CMD_FAILURE || result == CMD_NOT_IMPLEMENTED
  55           || result == CMD_CASCADING_FAILURE);
  56 }
  57
  58 /* Returns true if RESULT indicates success,
  59    false otherwise. */
  60 bool
  61 cmd_result_is_success (enum cmd_result result)
  62 {
  63   assert (cmd_result_is_valid (result));
  64   return result > 0;
  65 }
  66
  67 /* Returns true if RESULT indicates failure,
  68    false otherwise. */
  69 bool
  70 cmd_result_is_failure (enum cmd_result result)
  71 {
  72   assert (cmd_result_is_valid (result));
  73   return result < 0;
  74 }
  75 \f
  76 /* Command processing states. */
  77 enum states
  78   {
  79     S_INITIAL = 0x01,         /* Allowed before active file defined. */
  80     S_DATA = 0x02,            /* Allowed after active file defined. */
  81     S_INPUT_PROGRAM = 0x04,   /* Allowed in INPUT PROGRAM. */
  82     S_FILE_TYPE = 0x08,       /* Allowed in FILE TYPE. */
  83     S_ANY = 0x0f              /* Allowed anywhere. */
  84   };
  85
  86 /* Other command requirements. */
  87 enum flags
  88   {
  89     F_ENHANCED = 0x10,        /* Allowed only in enhanced syntax mode. */
  90     F_TESTING = 0x20,         /* Allowed only in testing mode. */
  91     F_KEEP_FINAL_TOKEN = 0x40,/* Don't skip final token in command name. */
  92     F_ABBREV = 0x80           /* Not a candidate for name completion. */
  93   };
  94
  95 /* A single command. */
  96 struct command
  97   {
  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. */
 102   };
 103
 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[] =
 108   {
 109 #include "command.def"
 110   };
 111 #undef DEF_CMD
 112 #undef UNIMPL_CMD
 113
 114 static const size_t command_cnt = sizeof commands / sizeof *commands;
 115
 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 const struct command *find_command (const char *name);
 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) == '.')
 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 size_t
 244 match_strings (const char *a, size_t a_len,
 245                const char *b, size_t b_len)
 246 {
 247   size_t match_len = 0;
 248
 249   while (a_len > 0 && b_len > 0)
 250     {
 251       /* Mismatch always returns zero. */
 252       if (toupper ((unsigned char) *a++) != toupper ((unsigned char) *b++))
 253         return 0;
 254
 255       /* Advance. */
 256       a_len--;
 257       b_len--;
 258       match_len++;
 259     }
 260
 261   return match_len;
 262 }
 263
 264 /* Returns the first character in the first word in STRING,
 265    storing the word's length in *WORD_LEN.  If no words remain,
 266    returns a null pointer and stores 0 in *WORD_LEN.  Words are
 267    sequences of alphanumeric characters or single
 268    non-alphanumeric characters.  Words are delimited by
 269    spaces. */
 270 static const char *
 271 find_word (const char *string, size_t *word_len)
 272 {
 273   /* Skip whitespace and asterisks. */
 274   while (isspace ((unsigned char) *string))
 275     string++;
 276
 277   /* End of string? */
 278   if (*string == '\0')
 279     {
 280       *word_len = 0;
 281       return NULL;
 282     }
 283
 284   /* Special one-character word? */
 285   if (!isalnum ((unsigned char) *string))
 286     {
 287       *word_len = 1;
 288       return string;
 289     }
 290
 291   /* Alphanumeric word. */
 292   *word_len = 1;
 293   while (isalnum ((unsigned char) string[*word_len]))
 294     (*word_len)++;
 295
 296   return string;
 297 }
 298
 299 /* Returns true if strings A and B can be confused based on
 300    their first three letters. */
 301 static bool
 302 conflicting_3char_prefixes (const char *a, const char *b)
 303 {
 304   size_t aw_len, bw_len;
 305   const char *aw, *bw;
 306
 307   aw = find_word (a, &aw_len);
 308   bw = find_word (b, &bw_len);
 309   assert (aw != NULL && bw != NULL);
 310
 311   /* Words that are the same don't conflict. */
 312   if (aw_len == bw_len && !buf_compare_case (aw, bw, aw_len))
 313     return false;
 314
 315   /* Words that are otherwise the same in the first three letters
 316      do conflict. */
 317   return ((aw_len > 3 && bw_len > 3)
 318           || (aw_len == 3 && bw_len > 3)
 319           || (bw_len == 3 && aw_len > 3)) && !buf_compare_case (aw, bw, 3);
 320 }
 321
 322 /* Returns true if CMD can be confused with another command
 323    based on the first three letters of its first word. */
 324 static bool
 325 conflicting_3char_prefix_command (const struct command *cmd)
 326 {
 327   assert (cmd >= commands && cmd < commands + command_cnt);
 328
 329   return ((cmd > commands
 330            && conflicting_3char_prefixes (cmd[-1].name, cmd[0].name))
 331           || (cmd < commands + command_cnt
 332               && conflicting_3char_prefixes (cmd[0].name, cmd[1].name)));
 333 }
 334
 335 /* Ways that a set of words can match a command name. */
 336 enum command_match
 337   {
 338     MISMATCH,           /* Not a match. */
 339     PARTIAL_MATCH,      /* The words begin the command name. */
 340     COMPLETE_MATCH      /* The words are the command name. */
 341   };
 342
 343 /* Figures out how well the WORD_CNT words in WORDS match CMD,
 344    and returns the appropriate enum value.  If WORDS are a
 345    partial match for CMD and the next word in CMD is a dash, then
 346    *DASH_POSSIBLE is set to 1 if DASH_POSSIBLE is non-null;
 347    otherwise, *DASH_POSSIBLE is unchanged. */
 348 static enum command_match
 349 cmd_match_words (const struct command *cmd,
 350                  char *const words[], size_t word_cnt,
 351                  int *dash_possible)
 352 {
 353   const char *word;
 354   size_t word_len;
 355   size_t word_idx;
 356
 357   for (word = find_word (cmd->name, &word_len), word_idx = 0;
 358        word != NULL && word_idx < word_cnt;
 359        word = find_word (word + word_len, &word_len), word_idx++)
 360     if (word_len != strlen (words[word_idx])
 361         || buf_compare_case (word, words[word_idx], word_len))
 362       {
 363         size_t match_chars = match_strings (word, word_len,
 364                                             words[word_idx],
 365                                             strlen (words[word_idx]));
 366         if (match_chars == 0)
 367           {
 368             /* Mismatch. */
 369             return MISMATCH;
 370           }
 371         else if (match_chars == 1 || match_chars == 2)
 372           {
 373             /* One- and two-character abbreviations are not
 374                acceptable. */
 375             return MISMATCH;
 376           }
 377         else if (match_chars == 3)
 378           {
 379             /* Three-character abbreviations are acceptable
 380                in the first word of a command if there are
 381                no name conflicts.  They are always
 382                acceptable after the first word. */
 383             if (word_idx == 0 && conflicting_3char_prefix_command (cmd))
 384               return MISMATCH;
 385           }
 386         else /* match_chars > 3 */
 387           {
 388             /* Four-character and longer abbreviations are
 389                always acceptable.  */
 390           }
 391       }
 392
 393   if (word == NULL && word_idx == word_cnt)
 394     {
 395       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR"}. */
 396       return COMPLETE_MATCH;
 397     }
 398   else if (word == NULL)
 399     {
 400       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR", "BAZ"}. */
 401       return MISMATCH;
 402     }
 403   else
 404     {
 405       /* cmd->name = "FOO BAR BAZ", words[] = {"FOO", "BAR"}. */
 406       if (word[0] == '-' && dash_possible != NULL)
 407         *dash_possible = 1;
 408       return PARTIAL_MATCH;
 409     }
 410 }
 411
 412 /* Returns the number of commands for which the WORD_CNT words in
 413    WORDS are a partial or complete match.  If some partial match
 414    has a dash as the next word, then *DASH_POSSIBLE is set to 1,
 415    otherwise it is set to 0. */
 416 static int
 417 count_matching_commands (char *const words[], size_t word_cnt,
 418                          int *dash_possible)
 419 {
 420   const struct command *cmd;
 421   int cmd_match_count;
 422
 423   cmd_match_count = 0;
 424   *dash_possible = 0;
 425   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 426     if (cmd_match_words (cmd, words, word_cnt, dash_possible) != MISMATCH)
 427       cmd_match_count++;
 428
 429   return cmd_match_count;
 430 }
 431
 432 /* Returns the command for which the WORD_CNT words in WORDS are
 433    a complete match.  Returns a null pointer if no such command
 434    exists. */
 435 static const struct command *
 436 get_complete_match (char *const words[], size_t word_cnt)
 437 {
 438   const struct command *cmd;
 439
 440   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 441     if (cmd_match_words (cmd, words, word_cnt, NULL) == COMPLETE_MATCH)
 442       return cmd;
 443
 444   return NULL;
 445 }
 446
 447 /* Returns the command with the given exact NAME.
 448    Aborts if no such command exists. */
 449 static const struct command *
 450 find_command (const char *name)
 451 {
 452   const struct command *cmd;
 453
 454   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 455     if (!strcmp (cmd->name, name))
 456       return cmd;
 457   NOT_REACHED ();
 458 }
 459
 460 /* Frees the WORD_CNT words in WORDS. */
 461 static void
 462 free_words (char *words[], size_t word_cnt)
 463 {
 464   size_t idx;
 465
 466   for (idx = 0; idx < word_cnt; idx++)
 467     free (words[idx]);
 468 }
 469
 470 /* Flags an error that the command whose name is given by the
 471    WORD_CNT words in WORDS is unknown. */
 472 static void
 473 unknown_command_error (struct lexer *lexer, char *const words[], size_t word_cnt)
 474 {
 475   if (word_cnt == 0)
 476     lex_error (lexer, _("expecting command name"));
 477   else
 478     {
 479       struct string s;
 480       size_t i;
 481
 482       ds_init_empty (&s);
 483       for (i = 0; i < word_cnt; i++)
 484         {
 485           if (i != 0)
 486             ds_put_char (&s, ' ');
 487           ds_put_cstr (&s, words[i]);
 488         }
 489
 490       msg (SE, _("Unknown command %s."), ds_cstr (&s));
 491
 492       ds_destroy (&s);
 493     }
 494 }
 495
 496 /* Parse the command name and return a pointer to the corresponding
 497    struct command if successful.
 498    If not successful, return a null pointer. */
 499 static const struct command *
 500 parse_command_name (struct lexer *lexer)
 501 {
 502   char *words[16];
 503   int word_cnt;
 504   int complete_word_cnt;
 505   int dash_possible;
 506
 507   if (lex_token (lexer) == T_EXP ||
 508                   lex_token (lexer) == '*' || lex_token (lexer) == '[')
 509     return find_command ("COMMENT");
 510
 511   dash_possible = 0;
 512   word_cnt = complete_word_cnt = 0;
 513   while (lex_token (lexer) == T_ID || (dash_possible && lex_token (lexer) == '-'))
 514     {
 515       int cmd_match_cnt;
 516
 517       assert (word_cnt < sizeof words / sizeof *words);
 518       if (lex_token (lexer) == T_ID)
 519         {
 520           words[word_cnt] = ds_xstrdup (lex_tokstr (lexer));
 521           str_uppercase (words[word_cnt]);
 522         }
 523       else if (lex_token (lexer) == '-')
 524         words[word_cnt] = xstrdup ("-");
 525       word_cnt++;
 526
 527       cmd_match_cnt = count_matching_commands (words, word_cnt,
 528                                                &dash_possible);
 529       if (cmd_match_cnt == 0)
 530         break;
 531       else if (cmd_match_cnt == 1)
 532         {
 533           const struct command *command = get_complete_match (words, word_cnt);
 534           if (command != NULL)
 535             {
 536               if (!(command->flags & F_KEEP_FINAL_TOKEN))
 537                 lex_get (lexer);
 538               free_words (words, word_cnt);
 539               return command;
 540             }
 541         }
 542       else /* cmd_match_cnt > 1 */
 543         {
 544           /* Do we have a complete command name so far? */
 545           if (get_complete_match (words, word_cnt) != NULL)
 546             complete_word_cnt = word_cnt;
 547         }
 548       lex_get (lexer);
 549     }
 550
 551   /* If we saw a complete command name earlier, drop back to
 552      it. */
 553   if (complete_word_cnt)
 554     {
 555       int pushback_word_cnt;
 556       const struct command *command;
 557
 558       /* Get the command. */
 559       command = get_complete_match (words, complete_word_cnt);
 560       assert (command != NULL);
 561
 562       /* Figure out how many words we want to keep.
 563          We normally want to swallow the entire command. */
 564       pushback_word_cnt = complete_word_cnt + 1;
 565       if (command->flags & F_KEEP_FINAL_TOKEN)
 566         pushback_word_cnt--;
 567
 568       /* FIXME: We only support one-token pushback. */
 569       assert (pushback_word_cnt + 1 >= word_cnt);
 570
 571       while (word_cnt > pushback_word_cnt)
 572         {
 573           word_cnt--;
 574           if (strcmp (words[word_cnt], "-"))
 575             lex_put_back_id (lexer, words[word_cnt]);
 576           else
 577             lex_put_back (lexer, '-');
 578           free (words[word_cnt]);
 579         }
 580
 581       free_words (words, word_cnt);
 582       return command;
 583     }
 584
 585   /* We didn't get a valid command name. */
 586   unknown_command_error (lexer, words, word_cnt);
 587   free_words (words, word_cnt);
 588   return NULL;
 589 }
 590
 591 /* Returns true if COMMAND is allowed in STATE,
 592    false otherwise. */
 593 static bool
 594 in_correct_state (const struct command *command, enum cmd_state state)
 595 {
 596   return ((state == CMD_STATE_INITIAL && command->states & S_INITIAL)
 597           || (state == CMD_STATE_DATA && command->states & S_DATA)
 598           || (state == CMD_STATE_INPUT_PROGRAM
 599               && command->states & S_INPUT_PROGRAM)
 600           || (state == CMD_STATE_FILE_TYPE && command->states & S_FILE_TYPE));
 601 }
 602
 603 /* Emits an appropriate error message for trying to invoke
 604    COMMAND in STATE. */
 605 static bool
 606 report_state_mismatch (const struct command *command, enum cmd_state state)
 607 {
 608   assert (!in_correct_state (command, state));
 609   if (state == CMD_STATE_INITIAL || state == CMD_STATE_DATA)
 610     {
 611       switch (command->states)
 612         {
 613           /* One allowed state. */
 614         case S_INITIAL:
 615           msg (SE, _("%s is allowed only before the active file has "
 616                      "been defined."), command->name);
 617           break;
 618         case S_DATA:
 619           msg (SE, _("%s is allowed only after the active file has "
 620                      "been defined."), command->name);
 621           break;
 622         case S_INPUT_PROGRAM:
 623           msg (SE, _("%s is allowed only inside INPUT PROGRAM."),
 624                command->name);
 625           break;
 626         case S_FILE_TYPE:
 627           msg (SE, _("%s is allowed only inside FILE TYPE."), command->name);
 628           break;
 629
 630           /* Two allowed states. */
 631         case S_INITIAL | S_DATA:
 632           NOT_REACHED ();
 633         case S_INITIAL | S_INPUT_PROGRAM:
 634           msg (SE, _("%s is allowed only before the active file has "
 635                      "been defined or inside INPUT PROGRAM."), command->name);
 636           break;
 637         case S_INITIAL | S_FILE_TYPE:
 638           msg (SE, _("%s is allowed only before the active file has "
 639                      "been defined or inside FILE TYPE."), command->name);
 640           break;
 641         case S_DATA | S_INPUT_PROGRAM:
 642           msg (SE, _("%s is allowed only after the active file has "
 643                      "been defined or inside INPUT PROGRAM."), command->name);
 644           break;
 645         case S_DATA | S_FILE_TYPE:
 646           msg (SE, _("%s is allowed only after the active file has "
 647                      "been defined or inside FILE TYPE."), command->name);
 648           break;
 649         case S_INPUT_PROGRAM | S_FILE_TYPE:
 650           msg (SE, _("%s is allowed only inside INPUT PROGRAM "
 651                      "or inside FILE TYPE."), command->name);
 652           break;
 653
 654           /* Three allowed states. */
 655         case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
 656           msg (SE, _("%s is allowed only after the active file has "
 657                      "been defined, inside INPUT PROGRAM, or inside "
 658                      "FILE TYPE."), command->name);
 659           break;
 660         case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
 661           msg (SE, _("%s is allowed only before the active file has "
 662                      "been defined, inside INPUT PROGRAM, or inside "
 663                      "FILE TYPE."), command->name);
 664           break;
 665         case S_INITIAL | S_DATA | S_FILE_TYPE:
 666           NOT_REACHED ();
 667         case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
 668           NOT_REACHED ();
 669
 670           /* Four allowed states. */
 671         case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
 672           NOT_REACHED ();
 673
 674         default:
 675           NOT_REACHED ();
 676         }
 677     }
 678   else if (state == CMD_STATE_INPUT_PROGRAM)
 679     msg (SE, _("%s is not allowed inside %s."), command->name, "INPUT PROGRAM" );
 680   else if (state == CMD_STATE_FILE_TYPE)
 681     msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
 682
 683   return false;
 684 }
 685 \f
 686 /* Command name completion. */
 687
 688 static enum cmd_state completion_state = CMD_STATE_INITIAL;
 689
 690 static void
 691 set_completion_state (enum cmd_state state)
 692 {
 693   completion_state = state;
 694 }
 695
 696 /* Returns the next possible completion of a command name that
 697    begins with PREFIX, in the current command state, or a null
 698    pointer if no completions remain.
 699    Before calling the first time, set *CMD to a null pointer. */
 700 const char *
 701 cmd_complete (const char *prefix, const struct command **cmd)
 702 {
 703   if (*cmd == NULL)
 704     *cmd = commands;
 705
 706   for (; *cmd < commands + command_cnt; (*cmd)++)
 707     if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
 708         && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
 709         && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
 710         && !((*cmd)->flags & F_ABBREV)
 711         && ((*cmd)->function != NULL)
 712         && in_correct_state (*cmd, completion_state))
 713       return (*cmd)++->name;
 714
 715   return NULL;
 716 }
 717 \f
 718 /* Simple commands. */
 719
 720 /* Parse and execute FINISH command. */
 721 int
 722 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
 723 {
 724   return CMD_FINISH;
 725 }
 726
 727 /* Parses the N command. */
 728 int
 729 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
 730 {
 731   /* Value for N. */
 732   int x;
 733
 734   if (!lex_force_int (lexer))
 735     return CMD_FAILURE;
 736   x = lex_integer (lexer);
 737   lex_get (lexer);
 738   if (!lex_match_id (lexer, "ESTIMATED"))
 739     dict_set_case_limit (dataset_dict (ds), x);
 740
 741   return lex_end_of_command (lexer);
 742 }
 743
 744 /* Parses, performs the EXECUTE procedure. */
 745 int
 746 cmd_execute (struct lexer *lexer, struct dataset *ds)
 747 {
 748   bool ok = casereader_destroy (proc_open (ds));
 749   if (!proc_commit (ds) || !ok)
 750     return CMD_CASCADING_FAILURE;
 751   return lex_end_of_command (lexer);
 752 }
 753
 754 /* Parses, performs the ERASE command. */
 755 int
 756 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
 757 {
 758   if (settings_get_safer_mode ())
 759     {
 760       msg (SE, _("This command not allowed when the SAFER option is set."));
 761       return CMD_FAILURE;
 762     }
 763
 764   if (!lex_force_match_id (lexer, "FILE"))
 765     return CMD_FAILURE;
 766   lex_match (lexer, '=');
 767   if (!lex_force_string (lexer))
 768     return CMD_FAILURE;
 769
 770   if (remove (ds_cstr (lex_tokstr (lexer))) == -1)
 771     {
 772       msg (SW, _("Error removing `%s': %s."),
 773            ds_cstr (lex_tokstr (lexer)), strerror (errno));
 774       return CMD_FAILURE;
 775     }
 776
 777   return CMD_SUCCESS;
 778 }
 779
 780 /* Parses, performs the NEW FILE command. */
 781 int
 782 cmd_new_file (struct lexer *lexer, struct dataset *ds)
 783 {
 784   proc_discard_active_file (ds);
 785
 786   return lex_end_of_command (lexer);
 787 }
 788
 789 /* Parses a comment. */
 790 int
 791 cmd_comment (struct lexer *lexer, struct dataset *ds UNUSED)
 792 {
 793   lex_skip_comment (lexer);
 794   return CMD_SUCCESS;
 795 }