Fix assertion for proper Huffman merge pattern: 0 == 1 modulo 1.
[pspp] / src / command.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 #include <config.h>
21 #include "error.h"
22 #include "command.h"
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include "alloc.h"
28 #include "dictionary.h"
29 #include "error.h"
30 #include "getline.h"
31 #include "lexer.h"
32 #include "main.h"
33 #include "settings.h"
34 #include "som.h"
35 #include "str.h"
36 #include "tab.h"
37 #include "var.h"
38 #include "vfm.h"
39
40 #if HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43
44 #if HAVE_SYS_WAIT_H
45 #include <sys/wait.h>
46 #endif
47 \f
48 /* Global variables. */
49
50 /* A STATE_* constant giving the current program state. */
51 int pgm_state;
52
53 /* The name of the procedure currently executing, if any. */
54 const char *cur_proc;
55 \f
56 /* Static variables. */
57
58 /* A single command. */
59 struct command
60   {
61     const char *name;           /* Command name. */
62     int transition[4];          /* Transitions to make from each state. */
63     int (*func) (void);         /* Function to call. */
64     int skip_entire_name;       /* If zero, we don't skip the
65                                    final token in the command name. */
66   };
67
68 /* Define the command array. */
69 #define DEFCMD(NAME, T1, T2, T3, T4, FUNC)              \
70         {NAME, {T1, T2, T3, T4}, FUNC, 1},
71 #define SPCCMD(NAME, T1, T2, T3, T4, FUNC)              \
72         {NAME, {T1, T2, T3, T4}, FUNC, 0},
73 #define UNIMPL(NAME, T1, T2, T3, T4)                    \
74         {NAME, {T1, T2, T3, T4}, NULL, 1},
75 static const struct command commands[] = 
76   {
77 #include "command.def"
78   };
79 #undef DEFCMD
80 #undef UNIMPL
81
82 #define COMMAND_CNT (sizeof commands / sizeof *commands)
83 \f
84 /* Command parser. */
85
86 static const struct command *parse_command_name (void);
87
88 /* Determines whether command C is appropriate to call in this
89    part of a FILE TYPE structure. */
90 static int
91 FILE_TYPE_okay (const struct command *c)
92 {
93   int okay = 0;
94   
95   if (c->func != cmd_record_type
96       && c->func != cmd_data_list
97       && c->func != cmd_repeating_data
98       && c->func != cmd_end_file_type)
99     msg (SE, _("%s not allowed inside FILE TYPE/END FILE TYPE."), c->name);
100 #if 0
101   /* FIXME */
102   else if (c->func == cmd_repeating_data && fty.type == FTY_GROUPED)
103     msg (SE, _("%s not allowed inside FILE TYPE GROUPED/END FILE TYPE."),
104          c->name);
105   else if (!fty.had_rec_type && c->func != cmd_record_type)
106     msg (SE, _("RECORD TYPE must be the first command inside a "
107                       "FILE TYPE structure."));
108 #endif
109   else
110     okay = 1;
111
112 #if 0
113   if (c->func == cmd_record_type)
114     fty.had_rec_type = 1;
115 #endif
116
117   return okay;
118 }
119
120 /* Parses an entire PSPP command.  This includes everything from the
121    command name to the terminating dot.  Does most of its work by
122    passing it off to the respective command dispatchers.  Only called
123    by parse() in main.c. */
124 int
125 cmd_parse (void)
126 {
127   const struct command *cp;     /* Iterator used to find the proper command. */
128
129 #if C_ALLOCA
130   /* The generic alloca package performs garbage collection when it is
131      called with an argument of zero. */
132   alloca (0);
133 #endif /* C_ALLOCA */
134
135   /* Null commands can result from extra empty lines. */
136   if (token == '.')
137     return CMD_SUCCESS;
138
139   /* Parse comments. */
140   if ((token == T_ID && !strcmp (tokid, "COMMENT"))
141       || token == T_EXP || token == '*' || token == '[')
142     {
143       lex_skip_comment ();
144       return CMD_SUCCESS;
145     }
146
147   /* Otherwise the line must begin with a command name, which is
148      always an ID token. */
149   if (token != T_ID)
150     {
151       lex_error (_("expecting command name"));
152       return CMD_FAILURE;
153     }
154
155   /* Parse the command name. */
156   cp = parse_command_name ();
157   if (cp == NULL)
158     return CMD_FAILURE;
159   if (cp->func == NULL)
160     {
161       msg (SE, _("%s is not yet implemented."), cp->name);
162       while (token && token != '.')
163         lex_get ();
164       return CMD_SUCCESS;
165     }
166
167   /* If we're in a FILE TYPE structure, only certain commands can be
168      allowed. */
169   if (pgm_state == STATE_INPUT
170       && case_source_is_class (vfm_source, &file_type_source_class)
171       && !FILE_TYPE_okay (cp))
172     return CMD_FAILURE;
173
174   /* Certain state transitions are not allowed.  Check for these. */
175   assert (pgm_state >= 0 && pgm_state < STATE_ERROR);
176   if (cp->transition[pgm_state] == STATE_ERROR)
177     {
178       static const char *state_name[4] =
179       {
180         N_("%s is not allowed (1) before a command to specify the "
181            "input program, such as DATA LIST, (2) between FILE TYPE "
182            "and END FILE TYPE, (3) between INPUT PROGRAM and END "
183            "INPUT PROGRAM."),
184         N_("%s is not allowed within an input program."),
185         N_("%s is only allowed within an input program."),
186         N_("%s is only allowed within an input program."),
187       };
188
189       msg (SE, gettext (state_name[pgm_state]), cp->name);
190       return CMD_FAILURE;
191     }
192
193   /* The structured output manager numbers all its tables.  Increment
194      the major table number for each separate procedure. */
195   som_new_series ();
196   
197   {
198     int result;
199     
200     /* Call the command dispatcher.  Save and restore the name of
201        the current command around this call. */
202     {
203       const char *prev_proc;
204       
205       prev_proc = cur_proc;
206       cur_proc = cp->name;
207       result = cp->func ();
208       cur_proc = prev_proc;
209     }
210     
211     /* Perform the state transition if the command completed
212        successfully (at least in part). */
213     if (result != CMD_FAILURE)
214       {
215         pgm_state = cp->transition[pgm_state];
216
217         if (pgm_state == STATE_ERROR)
218           {
219             discard_variables ();
220             pgm_state = STATE_INIT;
221           }
222       }
223
224     /* Pass the command's success value up to the caller. */
225     return result;
226   }
227 }
228
229 static size_t
230 match_strings (const char *a, size_t a_len,
231                const char *b, size_t b_len) 
232 {
233   size_t match_len = 0;
234   
235   while (a_len > 0 && b_len > 0) 
236     {
237       /* Mismatch always returns zero. */
238       if (*a++ != *b++)
239         return 0;
240
241       /* Advance. */
242       a_len--;
243       b_len--;
244       match_len++;
245     }
246
247   return match_len;
248 }
249
250 /* Returns the first character in the first word in STRING,
251    storing the word's length in *WORD_LEN.  If no words remain,
252    returns a null pointer and stores 0 in *WORD_LEN.  Words are
253    sequences of alphanumeric characters or single
254    non-alphanumeric characters.  Words are delimited by
255    spaces. */
256 static const char *
257 find_word (const char *string, size_t *word_len) 
258 {
259   /* Skip whitespace and asterisks. */
260   while (isspace (*string))
261     string++;
262
263   /* End of string? */
264   if (*string == '\0') 
265     {
266       *word_len = 0;
267       return NULL;
268     }
269
270   /* Special one-character word? */
271   if (!isalnum ((unsigned char) *string)) 
272     {
273       *word_len = 1;
274       return string;
275     }
276
277   /* Alphanumeric word. */
278   *word_len = 1;
279   while (isalnum ((unsigned char) string[*word_len]))
280     (*word_len)++;
281
282   return string;
283 }
284
285 /* Returns nonzero if strings A and B can be confused based on
286    their first three letters. */
287 static int
288 conflicting_3char_prefixes (const char *a, const char *b) 
289 {
290   size_t aw_len, bw_len;
291   const char *aw, *bw;
292
293   aw = find_word (a, &aw_len);
294   bw = find_word (b, &bw_len);
295   assert (aw != NULL && bw != NULL);
296
297   /* Words that are the same don't conflict. */
298   if (aw_len == bw_len && !memcmp (aw, bw, aw_len))
299     return 0;
300   
301   /* Words that are otherwise the same in the first three letters
302      do conflict. */
303   return ((aw_len > 3 && bw_len > 3)
304           || (aw_len == 3 && bw_len > 3)
305           || (bw_len == 3 && aw_len > 3)) && !memcmp (aw, bw, 3);
306 }
307
308 /* Returns nonzero if CMD can be confused with another command
309    based on the first three letters of its first word. */
310 static int
311 conflicting_3char_prefix_command (const struct command *cmd) 
312 {
313   assert (cmd >= commands && cmd < commands + COMMAND_CNT);
314
315   return ((cmd > commands
316            && conflicting_3char_prefixes (cmd[-1].name, cmd[0].name))
317           || (cmd < commands + COMMAND_CNT
318               && conflicting_3char_prefixes (cmd[0].name, cmd[1].name)));
319 }
320
321 /* Ways that a set of words can match a command name. */
322 enum command_match
323   {
324     MISMATCH,           /* Not a match. */
325     PARTIAL_MATCH,      /* The words begin the command name. */
326     COMPLETE_MATCH      /* The words are the command name. */
327   };
328
329 /* Figures out how well the WORD_CNT words in WORDS match CMD,
330    and returns the appropriate enum value.  If WORDS are a
331    partial match for CMD and the next word in CMD is a dash, then
332    *DASH_POSSIBLE is set to 1 if DASH_POSSIBLE is non-null;
333    otherwise, *DASH_POSSIBLE is unchanged. */
334 static enum command_match
335 cmd_match_words (const struct command *cmd,
336                  char *const words[], size_t word_cnt,
337                  int *dash_possible)
338 {
339   const char *word;
340   size_t word_len;
341   size_t word_idx;
342
343   for (word = find_word (cmd->name, &word_len), word_idx = 0;
344        word != NULL && word_idx < word_cnt;
345        word = find_word (word + word_len, &word_len), word_idx++)
346     if (word_len != strlen (words[word_idx])
347         || memcmp (word, words[word_idx], word_len))
348       {
349         size_t match_chars = match_strings (word, word_len,
350                                             words[word_idx],
351                                             strlen (words[word_idx]));
352         if (match_chars == 0) 
353           {
354             /* Mismatch. */
355             return MISMATCH;
356           }
357         else if (match_chars == 1 || match_chars == 2) 
358           {
359             /* One- and two-character abbreviations are not
360                acceptable. */
361             return MISMATCH; 
362           }
363         else if (match_chars == 3) 
364           {
365             /* Three-character abbreviations are acceptable
366                in the first word of a command if there are
367                no name conflicts.  They are always
368                acceptable after the first word. */
369             if (word_idx == 0 && conflicting_3char_prefix_command (cmd))
370               return MISMATCH;
371           }
372         else /* match_chars > 3 */ 
373           {
374             /* Four-character and longer abbreviations are
375                always acceptable.  */
376           }
377       }
378
379   if (word == NULL && word_idx == word_cnt) 
380     {
381       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR"}. */
382       return COMPLETE_MATCH;
383     }
384   else if (word == NULL) 
385     {
386       /* cmd->name = "FOO BAR", words[] = {"FOO", "BAR", "BAZ"}. */
387       return MISMATCH; 
388     }
389   else 
390     {
391       /* cmd->name = "FOO BAR BAZ", words[] = {"FOO", "BAR"}. */
392       if (word[0] == '-' && dash_possible != NULL)
393         *dash_possible = 1;
394       return PARTIAL_MATCH; 
395     }
396 }
397
398 /* Returns the number of commands for which the WORD_CNT words in
399    WORDS are a partial or complete match.  If some partial match
400    has a dash as the next word, then *DASH_POSSIBLE is set to 1,
401    otherwise it is set to 0. */
402 static int
403 count_matching_commands (char *const words[], size_t word_cnt,
404                          int *dash_possible) 
405 {
406   const struct command *cmd;
407   int cmd_match_count;
408
409   cmd_match_count = 0;
410   *dash_possible = 0;
411   for (cmd = commands; cmd < commands + COMMAND_CNT; cmd++) 
412     if (cmd_match_words (cmd, words, word_cnt, dash_possible) != MISMATCH) 
413       cmd_match_count++; 
414
415   return cmd_match_count;
416 }
417
418 /* Returns the command for which the WORD_CNT words in WORDS are
419    a complete match.  Returns a null pointer if no such command
420    exists. */
421 static const struct command *
422 get_complete_match (char *const words[], size_t word_cnt) 
423 {
424   const struct command *cmd;
425   
426   for (cmd = commands; cmd < commands + COMMAND_CNT; cmd++) 
427     if (cmd_match_words (cmd, words, word_cnt, NULL) == COMPLETE_MATCH) 
428       return cmd; 
429   
430   return NULL;
431 }
432
433 /* Frees the WORD_CNT words in WORDS. */
434 static void
435 free_words (char *words[], size_t word_cnt) 
436 {
437   size_t idx;
438   
439   for (idx = 0; idx < word_cnt; idx++)
440     free (words[idx]);
441 }
442
443 /* Flags an error that the command whose name is given by the
444    WORD_CNT words in WORDS is unknown. */
445 static void
446 unknown_command_error (char *const words[], size_t word_cnt) 
447 {
448   size_t idx;
449   size_t words_len;
450   char *name, *cp;
451
452   words_len = 0;
453   for (idx = 0; idx < word_cnt; idx++)
454     words_len += strlen (words[idx]);
455
456   cp = name = xmalloc (words_len + word_cnt + 16);
457   for (idx = 0; idx < word_cnt; idx++) 
458     {
459       if (idx != 0)
460         *cp++ = ' ';
461       cp = stpcpy (cp, words[idx]);
462     }
463   *cp = '\0';
464
465   msg (SE, _("Unknown command %s."), name);
466
467   free (name);
468 }
469
470
471 /* Parse the command name and return a pointer to the corresponding
472    struct command if successful.
473    If not successful, return a null pointer. */
474 static const struct command *
475 parse_command_name (void)
476 {
477   char *words[16];
478   int word_cnt;
479   int complete_word_cnt;
480   int dash_possible;
481
482   dash_possible = 0;
483   word_cnt = complete_word_cnt = 0;
484   while (token == T_ID || (dash_possible && token == '-')) 
485     {
486       int cmd_match_cnt;
487       
488       assert (word_cnt < sizeof words / sizeof *words);
489       if (token == T_ID)
490         words[word_cnt++] = xstrdup (ds_c_str (&tokstr));
491       else
492         words[word_cnt++] = xstrdup ("-");
493
494       cmd_match_cnt = count_matching_commands (words, word_cnt,
495                                                &dash_possible);
496       if (cmd_match_cnt == 0) 
497         break;
498       else if (cmd_match_cnt == 1) 
499         {
500           const struct command *command = get_complete_match (words, word_cnt);
501           if (command != NULL) 
502             {
503               if (command->skip_entire_name)
504                 lex_get ();
505               free_words (words, word_cnt);
506               return command;
507             }
508         }
509       else /* cmd_match_cnt > 1 */
510         {
511           /* Do we have a complete command name so far? */
512           if (get_complete_match (words, word_cnt) != NULL)
513             complete_word_cnt = word_cnt;
514         }
515       lex_get ();
516     }
517
518   /* If we saw a complete command name earlier, drop back to
519      it. */
520   if (complete_word_cnt) 
521     {
522       int pushback_word_cnt;
523       const struct command *command;
524
525       /* Get the command. */
526       command = get_complete_match (words, complete_word_cnt);
527       assert (command != NULL);
528
529       /* Figure out how many words we want to keep.
530          We normally want to swallow the entire command. */
531       pushback_word_cnt = complete_word_cnt + 1;
532       if (!command->skip_entire_name)
533         pushback_word_cnt--;
534       
535       /* FIXME: We only support one-token pushback. */
536       assert (pushback_word_cnt + 1 >= word_cnt);
537
538       while (word_cnt > pushback_word_cnt) 
539         {
540           word_cnt--;
541           if (strcmp (words[word_cnt], "-")) 
542             lex_put_back_id (words[word_cnt]);
543           else
544             lex_put_back ('-');
545           free (words[word_cnt]);
546         }
547
548       free_words (words, word_cnt);
549       return command;
550     }
551
552   unknown_command_error (words, word_cnt);
553   free_words (words, word_cnt);
554   return NULL;
555 }
556 \f
557 /* Simple commands. */
558
559 /* Parse and execute EXIT command. */
560 int
561 cmd_exit (void)
562 {
563   if (getl_reading_script)
564     {
565       msg (SE, _("This command is not accepted in a syntax file.  "
566            "Instead, use FINISH to terminate a syntax file."));
567       lex_get ();
568     }
569   else
570     finished = 1;
571
572   return CMD_SUCCESS;
573 }
574
575 /* Parse and execute FINISH command. */
576 int
577 cmd_finish (void)
578 {
579   /* Do not check for `.'
580      Do not fetch any extra tokens. */
581   if (getl_interactive)
582     {
583       msg (SM, _("This command is not executed "
584            "in interactive mode.  Instead, PSPP drops "
585            "down to the command prompt.  Use EXIT if you really want "
586            "to quit."));
587       getl_close_all ();
588     }
589   else
590     finished = 1;
591
592   return CMD_SUCCESS;
593 }
594
595 /* Parses the N command. */
596 int
597 cmd_n_of_cases (void)
598 {
599   /* Value for N. */
600   int x;
601
602   if (!lex_force_int ())
603     return CMD_FAILURE;
604   x = lex_integer ();
605   lex_get ();
606   if (!lex_match_id ("ESTIMATED"))
607     dict_set_case_limit (default_dict, x);
608
609   return lex_end_of_command ();
610 }
611
612 /* Parses, performs the EXECUTE procedure. */
613 int
614 cmd_execute (void)
615 {
616   procedure (NULL, NULL);
617   return lex_end_of_command ();
618 }
619
620 /* Parses, performs the ERASE command. */
621 int
622 cmd_erase (void)
623 {
624   if ( safer_mode() ) 
625     { 
626       msg (SE, _("This command not allowed when the SAFER option is set.")); 
627       return CMD_FAILURE; 
628     } 
629   
630   if (!lex_force_match_id ("FILE"))
631     return CMD_FAILURE;
632   lex_match ('=');
633   if (!lex_force_string ())
634     return CMD_FAILURE;
635
636   if (remove (ds_c_str (&tokstr)) == -1)
637     {
638       msg (SW, _("Error removing `%s': %s."),
639            ds_c_str (&tokstr), strerror (errno));
640       return CMD_FAILURE;
641     }
642
643   return CMD_SUCCESS;
644 }
645
646 #ifdef unix
647 /* Spawn a shell process. */
648 static int
649 shell (void)
650 {
651   int pid;
652   
653   pid = fork ();
654   switch (pid)
655     {
656     case 0:
657       {
658         const char *shell_fn;
659         char *shell_process;
660         
661         {
662           int i;
663           
664           for (i = 3; i < 20; i++)
665             close (i);
666         }
667
668         shell_fn = getenv ("SHELL");
669         if (shell_fn == NULL)
670           shell_fn = "/bin/sh";
671         
672         {
673           const char *cp = strrchr (shell_fn, '/');
674           cp = cp ? &cp[1] : shell_fn;
675           shell_process = local_alloc (strlen (cp) + 8);
676           strcpy (shell_process, "-");
677           strcat (shell_process, cp);
678           if (strcmp (cp, "sh"))
679             shell_process[0] = '+';
680         }
681         
682         execl (shell_fn, shell_process, NULL);
683
684         err_hcf (1);
685       }
686
687     case -1:
688       msg (SE, _("Couldn't fork: %s."), strerror (errno));
689       return 0;
690
691     default:
692       assert (pid > 0);
693       while (wait (NULL) != pid)
694         ;
695       return 1;
696     }
697 }
698 #endif /* unix */
699
700 /* Parses the HOST command argument and executes the specified
701    command.  Returns a suitable command return code. */
702 static int
703 run_command (void)
704 {
705   const char *cmd;
706   int string;
707
708   /* Handle either a string argument or a full-line argument. */
709   {
710     int c = lex_look_ahead ();
711
712     if (c == '\'' || c == '"')
713       {
714         lex_get ();
715         if (!lex_force_string ())
716           return CMD_FAILURE;
717         cmd = ds_c_str (&tokstr);
718         string = 1;
719       }
720     else
721       {
722         cmd = lex_rest_of_line (NULL);
723         lex_discard_line ();
724         string = 0;
725       }
726   }
727
728   /* Execute the command. */
729   if (system (cmd) == -1)
730     msg (SE, _("Error executing command: %s."), strerror (errno));
731
732   /* Finish parsing. */
733   if (string)
734     {
735       lex_get ();
736
737       if (token != '.')
738         {
739           lex_error (_("expecting end of command"));
740           return CMD_TRAILING_GARBAGE;
741         }
742     }
743   else
744     token = '.';
745
746   return CMD_SUCCESS;
747 }
748
749 /* Parses, performs the HOST command. */
750 int
751 cmd_host (void)
752 {
753   int code;
754
755   if ( safer_mode() ) 
756     { 
757       msg (SE, _("This command not allowed when the SAFER option is set.")); 
758       return CMD_FAILURE; 
759     } 
760
761 #ifdef unix
762   /* Figure out whether to invoke an interactive shell or to execute a
763      single shell command. */
764   if (lex_look_ahead () == '.')
765     {
766       lex_get ();
767       code = shell () ? CMD_PART_SUCCESS_MAYBE : CMD_SUCCESS;
768     }
769   else
770     code = run_command ();
771 #else /* !unix */
772   /* Make sure that the system has a command interpreter, then run a
773      command. */
774   if (system (NULL) != 0)
775     code = run_command ();
776   else
777     {
778       msg (SE, _("No operating system support for this command."));
779       code = CMD_FAILURE;
780     }
781 #endif /* !unix */
782
783   return code ? CMD_FAILURE : CMD_SUCCESS;
784 }
785
786 /* Parses, performs the NEW FILE command. */
787 int
788 cmd_new_file (void)
789 {
790   discard_variables ();
791
792   return lex_end_of_command ();
793 }
794
795 /* Parses, performs the CLEAR TRANSFORMATIONS command. */
796 int
797 cmd_clear_transformations (void)
798 {
799   if (getl_reading_script)
800     {
801       msg (SW, _("This command is not valid in a syntax file."));
802       return CMD_FAILURE;
803     }
804
805   cancel_transformations ();
806   /* FIXME: what about variables created by transformations?
807      They need to be properly initialized. */
808
809   return CMD_SUCCESS;
810 }