src/language/command.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2009 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 #include <unistd.h>
  26
  27 #include <data/casereader.h>
  28 #include <data/dictionary.h>
  29 #include <data/procedure.h>
  30 #include <data/settings.h>
  31 #include <data/variable.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/message.h>
  38 #include <libpspp/str.h>
  39 #include <output/manager.h>
  40 #include <libpspp/getl.h>
  41
  42 #if HAVE_SYS_WAIT_H
  43 #include <sys/wait.h>
  44 #endif
  45
  46 #if HAVE_READLINE
  47 #include <readline/readline.h>
  48 #endif
  49
  50 #include "xalloc.h"
  51 #include "xmalloca.h"
  52
  53 #include "gettext.h"
  54 #define _(msgid) gettext (msgid)
  55 #define N_(msgid) msgid
  56 \f
  57 /* Returns true if RESULT is a valid "enum cmd_result",
  58    false otherwise. */
  59 static inline bool
  60 cmd_result_is_valid (enum cmd_result result)
  61 {
  62   return (result == CMD_SUCCESS || result == CMD_EOF || result == CMD_FINISH
  63           || (result >= CMD_PRIVATE_FIRST && result <= CMD_PRIVATE_LAST)
  64           || result == CMD_FAILURE || result == CMD_NOT_IMPLEMENTED
  65           || result == CMD_CASCADING_FAILURE);
  66 }
  67
  68 /* Returns true if RESULT indicates success,
  69    false otherwise. */
  70 bool
  71 cmd_result_is_success (enum cmd_result result)
  72 {
  73   assert (cmd_result_is_valid (result));
  74   return result > 0;
  75 }
  76
  77 /* Returns true if RESULT indicates failure,
  78    false otherwise. */
  79 bool
  80 cmd_result_is_failure (enum cmd_result result)
  81 {
  82   assert (cmd_result_is_valid (result));
  83   return result < 0;
  84 }
  85 \f
  86 /* Command processing states. */
  87 enum states
  88   {
  89     S_INITIAL = 0x01,         /* Allowed before active file defined. */
  90     S_DATA = 0x02,            /* Allowed after active file defined. */
  91     S_INPUT_PROGRAM = 0x04,   /* Allowed in INPUT PROGRAM. */
  92     S_FILE_TYPE = 0x08,       /* Allowed in FILE TYPE. */
  93     S_ANY = 0x0f              /* Allowed anywhere. */
  94   };
  95
  96 /* Other command requirements. */
  97 enum flags
  98   {
  99     F_ENHANCED = 0x10,        /* Allowed only in enhanced syntax mode. */
 100     F_TESTING = 0x20,         /* Allowed only in testing mode. */
 101     F_KEEP_FINAL_TOKEN = 0x40,/* Don't skip final token in command name. */
 102     F_ABBREV = 0x80           /* Not a candidate for name completion. */
 103   };
 104
 105 /* A single command. */
 106 struct command
 107   {
 108     enum states states;         /* States in which command is allowed. */
 109     enum flags flags;           /* Other command requirements. */
 110     const char *name;           /* Command name. */
 111     int (*function) (struct lexer *, struct dataset *); /* Function to call. */
 112   };
 113
 114 /* Define the command array. */
 115 #define DEF_CMD(STATES, FLAGS, NAME, FUNCTION) {STATES, FLAGS, NAME, FUNCTION},
 116 #define UNIMPL_CMD(NAME, DESCRIPTION) {S_ANY, 0, NAME, NULL},
 117 static const struct command commands[] =
 118   {
 119 #include "command.def"
 120   };
 121 #undef DEF_CMD
 122 #undef UNIMPL_CMD
 123
 124 static const size_t command_cnt = sizeof commands / sizeof *commands;
 125
 126 static bool in_correct_state (const struct command *, enum cmd_state);
 127 static bool report_state_mismatch (const struct command *, enum cmd_state);
 128 static const struct command *find_command (const char *name);
 129 static void set_completion_state (enum cmd_state);
 130 \f
 131 /* Command parser. */
 132
 133 static const struct command *parse_command_name (struct lexer *lexer);
 134 static enum cmd_result do_parse_command (struct lexer *, struct dataset *, enum cmd_state);
 135
 136 /* Parses an entire command, from command name to terminating
 137    dot.  On failure, skips to the terminating dot.
 138    Returns the command's success or failure result. */
 139 enum cmd_result
 140 cmd_parse_in_state (struct lexer *lexer, struct dataset *ds,
 141                     enum cmd_state state)
 142 {
 143   int result;
 144
 145   som_new_series ();
 146
 147   result = do_parse_command (lexer, ds, state);
 148   if (cmd_result_is_failure (result))
 149     lex_discard_rest_of_command (lexer);
 150
 151   assert (!proc_is_open (ds));
 152   unset_cmd_algorithm ();
 153   dict_clear_aux (dataset_dict (ds));
 154   if (!dataset_end_of_command (ds))
 155     result = CMD_CASCADING_FAILURE;
 156
 157   return result;
 158 }
 159
 160 enum cmd_result
 161 cmd_parse (struct lexer *lexer, struct dataset *ds)
 162 {
 163   const struct dictionary *dict = dataset_dict (ds);
 164   return cmd_parse_in_state (lexer, ds,
 165                              proc_has_active_file (ds) &&
 166                              dict_get_var_cnt (dict) > 0 ?
 167                              CMD_STATE_DATA : CMD_STATE_INITIAL);
 168 }
 169
 170
 171 /* Parses an entire command, from command name to terminating
 172    dot. */
 173 static enum cmd_result
 174 do_parse_command (struct lexer *lexer,
 175                   struct dataset *ds, enum cmd_state state)
 176 {
 177   const struct command *command;
 178   enum cmd_result result;
 179
 180   /* Read the command's first token. */
 181   prompt_set_style (PROMPT_FIRST);
 182   set_completion_state (state);
 183   lex_get (lexer);
 184   if (lex_token (lexer) == T_STOP)
 185     {
 186       result = CMD_EOF;
 187       goto finish;
 188     }
 189   else if (lex_token (lexer) == '.')
 190     {
 191       /* Null commands can result from extra empty lines. */
 192       result = CMD_SUCCESS;
 193       goto finish;
 194     }
 195
 196   prompt_set_style (PROMPT_LATER);
 197
 198   /* Parse the command name. */
 199   command = parse_command_name (lexer);
 200   if (command == NULL)
 201     {
 202       result = CMD_FAILURE;
 203       goto finish;
 204     }
 205   else if (command->function == NULL)
 206     {
 207       msg (SE, _("%s is not yet implemented."), command->name);
 208       result = CMD_NOT_IMPLEMENTED;
 209       goto finish;
 210     }
 211   else if ((command->flags & F_TESTING) && !settings_get_testing_mode ())
 212     {
 213       msg (SE, _("%s may be used only in testing mode."), command->name);
 214       result = CMD_FAILURE;
 215       goto finish;
 216     }
 217   else if ((command->flags & F_ENHANCED) && settings_get_syntax () != ENHANCED)
 218     {
 219       msg (SE, _("%s may be used only in enhanced syntax mode."),
 220            command->name);
 221       result = CMD_FAILURE;
 222       goto finish;
 223     }
 224   else if (!in_correct_state (command, state))
 225     {
 226       report_state_mismatch (command, state);
 227       result = CMD_FAILURE;
 228       goto finish;
 229     }
 230
 231   /* Execute command. */
 232   msg_set_command_name (command->name);
 233   som_set_command_name (command->name);
 234   result = command->function (lexer, ds);
 235   som_set_command_name (NULL);
 236   msg_set_command_name (NULL);
 237
 238   assert (cmd_result_is_valid (result));
 239
 240  finish:
 241   if ( cmd_result_is_failure (result))
 242     {
 243       const struct source_stream *cs = lex_get_source_stream (lexer);
 244
 245       if ( source_stream_current_error_mode (cs) == ERRMODE_STOP )
 246         {
 247           msg (MW, _("Error encountered while ERROR=STOP is effective."));
 248           result = CMD_CASCADING_FAILURE;
 249         }
 250     }
 251
 252   return result;
 253 }
 254
 255 static size_t
 256 match_strings (const char *a, size_t a_len,
 257                const char *b, size_t b_len)
 258 {
 259   size_t match_len = 0;
 260
 261   while (a_len > 0 && b_len > 0)
 262     {
 263       /* Mismatch always returns zero. */
 264       if (toupper ((unsigned char) *a++) != toupper ((unsigned char) *b++))
 265         return 0;
 266
 267       /* Advance. */
 268       a_len--;
 269       b_len--;
 270       match_len++;
 271     }
 272
 273   return match_len;
 274 }
 275
 276 /* Returns the first character in the first word in STRING,
 277    storing the word's length in *WORD_LEN.  If no words remain,
 278    returns a null pointer and stores 0 in *WORD_LEN.  Words are
 279    sequences of alphanumeric characters or single
 280    non-alphanumeric characters.  Words are delimited by
 281    spaces. */
 282 static const char *
 283 find_word (const char *string, size_t *word_len)
 284 {
 285   /* Skip whitespace and asterisks. */
 286   while (isspace ((unsigned char) *string))
 287     string++;
 288
 289   /* End of string? */
 290   if (*string == '\0')
 291     {
 292       *word_len = 0;
 293       return NULL;
 294     }
 295
 296   /* Special one-character word? */
 297   if (!isalnum ((unsigned char) *string))
 298     {
 299       *word_len = 1;
 300       return string;
 301     }
 302
 303   /* Alphanumeric word. */
 304   *word_len = 1;
 305   while (isalnum ((unsigned char) string[*word_len]))
 306     (*word_len)++;
 307
 308   return string;
 309 }
 310
 311 /* Returns true if strings A and B can be confused based on
 312    their first three letters. */
 313 static bool
 314 conflicting_3char_prefixes (const char *a, const char *b)
 315 {
 316   size_t aw_len, bw_len;
 317   const char *aw, *bw;
 318
 319   aw = find_word (a, &aw_len);
 320   bw = find_word (b, &bw_len);
 321   assert (aw != NULL && bw != NULL);
 322
 323   /* Words that are the same don't conflict. */
 324   if (aw_len == bw_len && !buf_compare_case (aw, bw, aw_len))
 325     return false;
 326
 327   /* Words that are otherwise the same in the first three letters
 328      do conflict. */
 329   return ((aw_len > 3 && bw_len > 3)
 330           || (aw_len == 3 && bw_len > 3)
 331           || (bw_len == 3 && aw_len > 3)) && !buf_compare_case (aw, bw, 3);
 332 }
 333
 334 /* Returns true if CMD can be confused with another command
 335    based on the first three letters of its first word. */
 336 static bool
 337 conflicting_3char_prefix_command (const struct command *cmd)
 338 {
 339   assert (cmd >= commands && cmd < commands + command_cnt);
 340
 341   return ((cmd > commands
 342            && conflicting_3char_prefixes (cmd[-1].name, cmd[0].name))
 343           || (cmd < commands + command_cnt
 344               && conflicting_3char_prefixes (cmd[0].name, cmd[1].name)));
 345 }
 346
 347 /* Ways that a set of words can match a command name. */
 348 enum command_match
 349   {
 350     MISMATCH,           /* Not a match. */
 351     PARTIAL_MATCH,      /* The words begin the command name. */
 352     COMPLETE_MATCH      /* The words are the command name. */
 353   };
 354
 355 /* Figures out how well the WORD_CNT words in WORDS match CMD,
 356    and returns the appropriate enum value.  If WORDS are a
 357    partial match for CMD and the next word in CMD is a dash, then
 358    *DASH_POSSIBLE is set to 1 if DASH_POSSIBLE is non-null;
 359    otherwise, *DASH_POSSIBLE is unchanged. */
 360 static enum command_match
 361 cmd_match_words (const struct command *cmd,
 362                  char *const words[], size_t word_cnt,
 363                  int *dash_possible)
 364 {
 365   const char *word;
 366   size_t word_len;
 367   size_t word_idx;
 368
 369   for (word = find_word (cmd->name, &word_len), word_idx = 0;
 370        word != NULL && word_idx < word_cnt;
 371        word = find_word (word + word_len, &word_len), word_idx++)
 372     if (word_len != strlen (words[word_idx])
 373         || buf_compare_case (word, words[word_idx], word_len))
 374       {
 375         size_t match_chars = match_strings (word, word_len,
 376                                             words[word_idx],
 377                                             strlen (words[word_idx]));
 378         if (match_chars == 0)
 379           {
 380             /* Mismatch. */
 381             return MISMATCH;
 382           }
 383         else if (match_chars == 1 || match_chars == 2)
 384           {
 385             /* One- and two-character abbreviations are not
 386                acceptable. */
 387             return MISMATCH;
 388           }
 389         else if (match_chars == 3)
 390           {
 391             /* Three-character abbreviations are acceptable
 392                in the first word of a command if there are
 393                no name conflicts.  They are always
 394                acceptable after the first word. */
 395             if (word_idx == 0 && conflicting_3char_prefix_command (cmd))
 396               return MISMATCH;
 397           }
 398         else /* match_chars > 3 */
 399           {
 400             /* Four-character and longer abbreviations are
 401                always acceptable.  */
 402           }
 403       }
 404
 405   if (word == NULL && word_idx == word_cnt)
 406     {
 407       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR"}. */
 408       return COMPLETE_MATCH;
 409     }
 410   else if (word == NULL)
 411     {
 412       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR", "BAZ"}. */
 413       return MISMATCH;
 414     }
 415   else
 416     {
 417       /* cmd->name = "FOO BAR BAZ", words[] = {"FOO", "BAR"}. */
 418       if (word[0] == '-' && dash_possible != NULL)
 419         *dash_possible = 1;
 420       return PARTIAL_MATCH;
 421     }
 422 }
 423
 424 /* Returns the number of commands for which the WORD_CNT words in
 425    WORDS are a partial or complete match.  If some partial match
 426    has a dash as the next word, then *DASH_POSSIBLE is set to 1,
 427    otherwise it is set to 0. */
 428 static int
 429 count_matching_commands (char *const words[], size_t word_cnt,
 430                          int *dash_possible)
 431 {
 432   const struct command *cmd;
 433   int cmd_match_count;
 434
 435   cmd_match_count = 0;
 436   *dash_possible = 0;
 437   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 438     if (cmd_match_words (cmd, words, word_cnt, dash_possible) != MISMATCH)
 439       cmd_match_count++;
 440
 441   return cmd_match_count;
 442 }
 443
 444 /* Returns the command for which the WORD_CNT words in WORDS are
 445    a complete match.  Returns a null pointer if no such command
 446    exists. */
 447 static const struct command *
 448 get_complete_match (char *const words[], size_t word_cnt)
 449 {
 450   const struct command *cmd;
 451
 452   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 453     if (cmd_match_words (cmd, words, word_cnt, NULL) == COMPLETE_MATCH)
 454       return cmd;
 455
 456   return NULL;
 457 }
 458
 459 /* Returns the command with the given exact NAME.
 460    Aborts if no such command exists. */
 461 static const struct command *
 462 find_command (const char *name)
 463 {
 464   const struct command *cmd;
 465
 466   for (cmd = commands; cmd < commands + command_cnt; cmd++)
 467     if (!strcmp (cmd->name, name))
 468       return cmd;
 469   NOT_REACHED ();
 470 }
 471
 472 /* Frees the WORD_CNT words in WORDS. */
 473 static void
 474 free_words (char *words[], size_t word_cnt)
 475 {
 476   size_t idx;
 477
 478   for (idx = 0; idx < word_cnt; idx++)
 479     free (words[idx]);
 480 }
 481
 482 /* Flags an error that the command whose name is given by the
 483    WORD_CNT words in WORDS is unknown. */
 484 static void
 485 unknown_command_error (struct lexer *lexer, char *const words[], size_t word_cnt)
 486 {
 487   if (word_cnt == 0)
 488     lex_error (lexer, _("expecting command name"));
 489   else
 490     {
 491       struct string s;
 492       size_t i;
 493
 494       ds_init_empty (&s);
 495       for (i = 0; i < word_cnt; i++)
 496         {
 497           if (i != 0)
 498             ds_put_char (&s, ' ');
 499           ds_put_cstr (&s, words[i]);
 500         }
 501
 502       msg (SE, _("Unknown command %s."), ds_cstr (&s));
 503
 504       ds_destroy (&s);
 505     }
 506 }
 507
 508 /* Parse the command name and return a pointer to the corresponding
 509    struct command if successful.
 510    If not successful, return a null pointer. */
 511 static const struct command *
 512 parse_command_name (struct lexer *lexer)
 513 {
 514   char *words[16];
 515   int word_cnt;
 516   int complete_word_cnt;
 517   int dash_possible;
 518
 519   if (lex_token (lexer) == T_EXP ||
 520                   lex_token (lexer) == '*' || lex_token (lexer) == '[')
 521     return find_command ("COMMENT");
 522
 523   dash_possible = 0;
 524   word_cnt = complete_word_cnt = 0;
 525   while (lex_token (lexer) == T_ID || (dash_possible && lex_token (lexer) == '-'))
 526     {
 527       int cmd_match_cnt;
 528
 529       assert (word_cnt < sizeof words / sizeof *words);
 530       if (lex_token (lexer) == T_ID)
 531         {
 532           words[word_cnt] = ds_xstrdup (lex_tokstr (lexer));
 533           str_uppercase (words[word_cnt]);
 534         }
 535       else if (lex_token (lexer) == '-')
 536         words[word_cnt] = xstrdup ("-");
 537       word_cnt++;
 538
 539       cmd_match_cnt = count_matching_commands (words, word_cnt,
 540                                                &dash_possible);
 541       if (cmd_match_cnt == 0)
 542         break;
 543       else if (cmd_match_cnt == 1)
 544         {
 545           const struct command *command = get_complete_match (words, word_cnt);
 546           if (command != NULL)
 547             {
 548               if (!(command->flags & F_KEEP_FINAL_TOKEN))
 549                 lex_get (lexer);
 550               free_words (words, word_cnt);
 551               return command;
 552             }
 553         }
 554       else /* cmd_match_cnt > 1 */
 555         {
 556           /* Do we have a complete command name so far? */
 557           if (get_complete_match (words, word_cnt) != NULL)
 558             complete_word_cnt = word_cnt;
 559         }
 560       lex_get (lexer);
 561     }
 562
 563   /* If we saw a complete command name earlier, drop back to
 564      it. */
 565   if (complete_word_cnt)
 566     {
 567       int pushback_word_cnt;
 568       const struct command *command;
 569
 570       /* Get the command. */
 571       command = get_complete_match (words, complete_word_cnt);
 572       assert (command != NULL);
 573
 574       /* Figure out how many words we want to keep.
 575          We normally want to swallow the entire command. */
 576       pushback_word_cnt = complete_word_cnt + 1;
 577       if (command->flags & F_KEEP_FINAL_TOKEN)
 578         pushback_word_cnt--;
 579
 580       /* FIXME: We only support one-token pushback. */
 581       assert (pushback_word_cnt + 1 >= word_cnt);
 582
 583       while (word_cnt > pushback_word_cnt)
 584         {
 585           word_cnt--;
 586           if (strcmp (words[word_cnt], "-"))
 587             lex_put_back_id (lexer, words[word_cnt]);
 588           else
 589             lex_put_back (lexer, '-');
 590           free (words[word_cnt]);
 591         }
 592
 593       free_words (words, word_cnt);
 594       return command;
 595     }
 596
 597   /* We didn't get a valid command name. */
 598   unknown_command_error (lexer, words, word_cnt);
 599   free_words (words, word_cnt);
 600   return NULL;
 601 }
 602
 603 /* Returns true if COMMAND is allowed in STATE,
 604    false otherwise. */
 605 static bool
 606 in_correct_state (const struct command *command, enum cmd_state state)
 607 {
 608   return ((state == CMD_STATE_INITIAL && command->states & S_INITIAL)
 609           || (state == CMD_STATE_DATA && command->states & S_DATA)
 610           || (state == CMD_STATE_INPUT_PROGRAM
 611               && command->states & S_INPUT_PROGRAM)
 612           || (state == CMD_STATE_FILE_TYPE && command->states & S_FILE_TYPE));
 613 }
 614
 615 /* Emits an appropriate error message for trying to invoke
 616    COMMAND in STATE. */
 617 static bool
 618 report_state_mismatch (const struct command *command, enum cmd_state state)
 619 {
 620   assert (!in_correct_state (command, state));
 621   if (state == CMD_STATE_INITIAL || state == CMD_STATE_DATA)
 622     {
 623       switch (command->states)
 624         {
 625           /* One allowed state. */
 626         case S_INITIAL:
 627           msg (SE, _("%s is allowed only before the active file has "
 628                      "been defined."), command->name);
 629           break;
 630         case S_DATA:
 631           msg (SE, _("%s is allowed only after the active file has "
 632                      "been defined."), command->name);
 633           break;
 634         case S_INPUT_PROGRAM:
 635           msg (SE, _("%s is allowed only inside INPUT PROGRAM."),
 636                command->name);
 637           break;
 638         case S_FILE_TYPE:
 639           msg (SE, _("%s is allowed only inside FILE TYPE."), command->name);
 640           break;
 641
 642           /* Two allowed states. */
 643         case S_INITIAL | S_DATA:
 644           NOT_REACHED ();
 645         case S_INITIAL | S_INPUT_PROGRAM:
 646           msg (SE, _("%s is allowed only before the active file has "
 647                      "been defined or inside INPUT PROGRAM."), command->name);
 648           break;
 649         case S_INITIAL | S_FILE_TYPE:
 650           msg (SE, _("%s is allowed only before the active file has "
 651                      "been defined or inside FILE TYPE."), command->name);
 652           break;
 653         case S_DATA | S_INPUT_PROGRAM:
 654           msg (SE, _("%s is allowed only after the active file has "
 655                      "been defined or inside INPUT PROGRAM."), command->name);
 656           break;
 657         case S_DATA | S_FILE_TYPE:
 658           msg (SE, _("%s is allowed only after the active file has "
 659                      "been defined or inside FILE TYPE."), command->name);
 660           break;
 661         case S_INPUT_PROGRAM | S_FILE_TYPE:
 662           msg (SE, _("%s is allowed only inside INPUT PROGRAM "
 663                      "or inside FILE TYPE."), command->name);
 664           break;
 665
 666           /* Three allowed states. */
 667         case S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
 668           msg (SE, _("%s is allowed only after the active file has "
 669                      "been defined, inside INPUT PROGRAM, or inside "
 670                      "FILE TYPE."), command->name);
 671           break;
 672         case S_INITIAL | S_INPUT_PROGRAM | S_FILE_TYPE:
 673           msg (SE, _("%s is allowed only before the active file has "
 674                      "been defined, inside INPUT PROGRAM, or inside "
 675                      "FILE TYPE."), command->name);
 676           break;
 677         case S_INITIAL | S_DATA | S_FILE_TYPE:
 678           NOT_REACHED ();
 679         case S_INITIAL | S_DATA | S_INPUT_PROGRAM:
 680           NOT_REACHED ();
 681
 682           /* Four allowed states. */
 683         case S_INITIAL | S_DATA | S_INPUT_PROGRAM | S_FILE_TYPE:
 684           NOT_REACHED ();
 685
 686         default:
 687           NOT_REACHED ();
 688         }
 689     }
 690   else if (state == CMD_STATE_INPUT_PROGRAM)
 691     msg (SE, _("%s is not allowed inside %s."), command->name, "INPUT PROGRAM" );
 692   else if (state == CMD_STATE_FILE_TYPE)
 693     msg (SE, _("%s is not allowed inside %s."), command->name, "FILE TYPE");
 694
 695   return false;
 696 }
 697 \f
 698 /* Command name completion. */
 699
 700 static enum cmd_state completion_state = CMD_STATE_INITIAL;
 701
 702 static void
 703 set_completion_state (enum cmd_state state)
 704 {
 705   completion_state = state;
 706 }
 707
 708 /* Returns the next possible completion of a command name that
 709    begins with PREFIX, in the current command state, or a null
 710    pointer if no completions remain.
 711    Before calling the first time, set *CMD to a null pointer. */
 712 const char *
 713 cmd_complete (const char *prefix, const struct command **cmd)
 714 {
 715   if (*cmd == NULL)
 716     *cmd = commands;
 717
 718   for (; *cmd < commands + command_cnt; (*cmd)++)
 719     if (!memcasecmp ((*cmd)->name, prefix, strlen (prefix))
 720         && (!((*cmd)->flags & F_TESTING) || settings_get_testing_mode ())
 721         && (!((*cmd)->flags & F_ENHANCED) || settings_get_syntax () == ENHANCED)
 722         && !((*cmd)->flags & F_ABBREV)
 723         && ((*cmd)->function != NULL)
 724         && in_correct_state (*cmd, completion_state))
 725       return (*cmd)++->name;
 726
 727   return NULL;
 728 }
 729 \f
 730 /* Simple commands. */
 731
 732 /* Parse and execute FINISH command. */
 733 int
 734 cmd_finish (struct lexer *lexer UNUSED, struct dataset *ds UNUSED)
 735 {
 736   return CMD_FINISH;
 737 }
 738
 739 /* Parses the N command. */
 740 int
 741 cmd_n_of_cases (struct lexer *lexer, struct dataset *ds)
 742 {
 743   /* Value for N. */
 744   int x;
 745
 746   if (!lex_force_int (lexer))
 747     return CMD_FAILURE;
 748   x = lex_integer (lexer);
 749   lex_get (lexer);
 750   if (!lex_match_id (lexer, "ESTIMATED"))
 751     dict_set_case_limit (dataset_dict (ds), x);
 752
 753   return lex_end_of_command (lexer);
 754 }
 755
 756 /* Parses, performs the EXECUTE procedure. */
 757 int
 758 cmd_execute (struct lexer *lexer, struct dataset *ds)
 759 {
 760   bool ok = casereader_destroy (proc_open (ds));
 761   if (!proc_commit (ds) || !ok)
 762     return CMD_CASCADING_FAILURE;
 763   return lex_end_of_command (lexer);
 764 }
 765
 766 /* Parses, performs the ERASE command. */
 767 int
 768 cmd_erase (struct lexer *lexer, struct dataset *ds UNUSED)
 769 {
 770   if (settings_get_safer_mode ())
 771     {
 772       msg (SE, _("This command not allowed when the SAFER option is set."));
 773       return CMD_FAILURE;
 774     }
 775
 776   if (!lex_force_match_id (lexer, "FILE"))
 777     return CMD_FAILURE;
 778   lex_match (lexer, '=');
 779   if (!lex_force_string (lexer))
 780     return CMD_FAILURE;
 781
 782   if (remove (ds_cstr (lex_tokstr (lexer))) == -1)
 783     {
 784       msg (SW, _("Error removing `%s': %s."),
 785            ds_cstr (lex_tokstr (lexer)), strerror (errno));
 786       return CMD_FAILURE;
 787     }
 788
 789   return CMD_SUCCESS;
 790 }
 791
 792 #if HAVE_FORK && HAVE_EXECL
 793 /* Spawn an interactive shell process. */
 794 static bool
 795 shell (void)
 796 {
 797   int pid;
 798
 799   pid = fork ();
 800   switch (pid)
 801     {
 802     case 0:
 803       {
 804         const char *shell_fn;
 805         char *shell_process;
 806
 807         {
 808           int i;
 809
 810           for (i = 3; i < 20; i++)
 811             close (i);
 812         }
 813
 814         shell_fn = getenv ("SHELL");
 815         if (shell_fn == NULL)
 816           shell_fn = "/bin/sh";
 817
 818         {
 819           const char *cp = strrchr (shell_fn, '/');
 820           cp = cp ? &cp[1] : shell_fn;
 821           shell_process = xmalloca (strlen (cp) + 8);
 822           strcpy (shell_process, "-");
 823           strcat (shell_process, cp);
 824           if (strcmp (cp, "sh"))
 825             shell_process[0] = '+';
 826         }
 827
 828         execl (shell_fn, shell_process, NULL);
 829
 830         _exit (1);
 831       }
 832
 833     case -1:
 834       msg (SE, _("Couldn't fork: %s."), strerror (errno));
 835       return false;
 836
 837     default:
 838       assert (pid > 0);
 839       while (wait (NULL) != pid)
 840         ;
 841       return true;
 842     }
 843 }
 844 #else /* !(HAVE_FORK && HAVE_EXECL) */
 845 /* Don't know how to spawn an interactive shell. */
 846 static bool
 847 shell (void)
 848 {
 849   msg (SE, _("Interactive shell not supported on this platform."));
 850   return false;
 851 }
 852 #endif
 853
 854 /* Executes the specified COMMAND in a subshell.  Returns true if
 855    successful, false otherwise. */
 856 static bool
 857 run_command (const char *command)
 858 {
 859   if (system (NULL) == 0)
 860     {
 861       msg (SE, _("Command shell not supported on this platform."));
 862       return false;
 863     }
 864
 865   /* Execute the command. */
 866   if (system (command) == -1)
 867     msg (SE, _("Error executing command: %s."), strerror (errno));
 868
 869   return true;
 870 }
 871
 872 /* Parses, performs the HOST command. */
 873 int
 874 cmd_host (struct lexer *lexer, struct dataset *ds UNUSED)
 875 {
 876   int look_ahead;
 877
 878   if (settings_get_safer_mode ())
 879     {
 880       msg (SE, _("This command not allowed when the SAFER option is set."));
 881       return CMD_FAILURE;
 882     }
 883
 884   look_ahead = lex_look_ahead (lexer);
 885   if (look_ahead == '.')
 886     {
 887       lex_get (lexer);
 888       return shell () ? CMD_SUCCESS : CMD_FAILURE;
 889     }
 890   else if (look_ahead == '\'' || look_ahead == '"')
 891     {
 892       bool ok;
 893
 894       lex_get (lexer);
 895       if (!lex_force_string (lexer))
 896         NOT_REACHED ();
 897       ok = run_command (ds_cstr (lex_tokstr (lexer)));
 898
 899       lex_get (lexer);
 900       return ok ? lex_end_of_command (lexer) : CMD_FAILURE;
 901     }
 902   else
 903     {
 904       bool ok = run_command (lex_rest_of_line (lexer));
 905       lex_discard_line (lexer);
 906       return ok ? CMD_SUCCESS : CMD_FAILURE;
 907     }
 908 }
 909
 910 /* Parses, performs the NEW FILE command. */
 911 int
 912 cmd_new_file (struct lexer *lexer, struct dataset *ds)
 913 {
 914   proc_discard_active_file (ds);
 915
 916   return lex_end_of_command (lexer);
 917 }
 918
 919 /* Parses a comment. */
 920 int
 921 cmd_comment (struct lexer *lexer, struct dataset *ds UNUSED)
 922 {
 923   lex_skip_comment (lexer);
 924   return CMD_SUCCESS;
 925 }