pintos-os.org Git - pspp/blob - src/ui/terminal/terminal-reader.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2007, 2009, 2010, 2011, 2013 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 <signal.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <stdbool.h>
  23 #include <stdio.h>
  24
  25
  26 #if HAVE_READLINE
  27 #include <readline/readline.h>
  28 #include <readline/history.h>
  29 #include <termios.h>
  30
  31 static char *history_file;
  32
  33 static char **complete_command_name (const char *, int, int);
  34 static char **dont_complete (const char *, int, int);
  35 static char *command_generator (const char *text, int state);
  36
  37 static const bool have_readline = true;
  38
  39 #else
  40 static const bool have_readline = false;
  41 static int rl_end;
  42 #endif
  43
  44
  45 #include "ui/terminal/terminal-reader.h"
  46 #include <sys/select.h>
  47 #include <sys/time.h>
  48 #include <sys/types.h>
  49
  50 #include <assert.h>
  51 #include <errno.h>
  52 #include <stdint.h>
  53 #include <stdlib.h>
  54
  55 #include "data/file-name.h"
  56 #include "data/settings.h"
  57 #include "language/command.h"
  58 #include "language/lexer/lexer.h"
  59 #include "libpspp/assertion.h"
  60 #include "libpspp/cast.h"
  61 #include "libpspp/message.h"
  62 #include "libpspp/prompt.h"
  63 #include "libpspp/str.h"
  64 #include "libpspp/version.h"
  65 #include "output/driver.h"
  66 #include "output/journal.h"
  67 #include "ui/terminal/terminal.h"
  68
  69 #include "gl/minmax.h"
  70 #include "gl/xalloc.h"
  71
  72 #include "gettext.h"
  73 #define _(msgid) gettext (msgid)
  74
  75 struct terminal_reader
  76   {
  77     struct lex_reader reader;
  78     struct substring s;
  79     size_t offset;
  80     bool eof;
  81   };
  82
  83 static int n_terminal_readers;
  84
  85 static void readline_init (void);
  86 static void readline_done (void);
  87 static bool readline_read (struct substring *, enum prompt_style);
  88
  89 /* Display a welcoming message. */
  90 static void
  91 welcome (void)
  92 {
  93   static bool welcomed = false;
  94   if (welcomed)
  95     return;
  96   welcomed = true;
  97   fputs ("PSPP is free software and you are welcome to distribute copies of "
  98          "it\nunder certain conditions; type \"show copying.\" to see the "
  99          "conditions.\nThere is ABSOLUTELY NO WARRANTY for PSPP; type \"show "
 100          "warranty.\" for details.\n", stdout);
 101   puts (stat_version);
 102   journal_init ();
 103 }
 104
 105 static struct terminal_reader *
 106 terminal_reader_cast (struct lex_reader *r)
 107 {
 108   return UP_CAST (r, struct terminal_reader, reader);
 109 }
 110
 111 /* Older libreadline versions do not provide rl_outstream.
 112    However, it is almost always going to be the same as stdout. */
 113 #if ! HAVE_RL_OUTSTREAM
 114 # define rl_outstream stdout
 115 #endif
 116
 117 /* Similarly, rl_echo_signal_char is fairly recent.
 118    We provide our own crude version if it is not present. */
 119 #if ! HAVE_RL_ECHO_SIGNAL_CHAR
 120 static void
 121 rl_echo_signal_char (int sig)
 122 {
 123 #if HAVE_TERMIOS_H
 124   struct termios t;
 125   if (0 == tcgetattr (0, &t))
 126     {
 127       cc_t c = t.c_cc[VINTR];
 128
 129       if (c >= 0  && c <= 'Z' - 'A')
 130         fprintf (rl_outstream, "^%c", 'A' + c - 1);
 131       else
 132         fprintf (rl_outstream, "%c", c);
 133     }
 134   else
 135 #endif
 136     fprintf (rl_outstream, "^C");
 137
 138   fflush (rl_outstream);
 139 }
 140 #endif
 141
 142
 143 static size_t
 144 terminal_reader_read (struct lex_reader *r_, char *buf, size_t n,
 145                       enum prompt_style prompt_style)
 146 {
 147   struct terminal_reader *r = terminal_reader_cast (r_);
 148   size_t chunk;
 149
 150   if (r->offset >= r->s.length && !r->eof)
 151     {
 152       welcome ();
 153       msg_ui_reset_counts ();
 154       output_flush ();
 155
 156       ss_dealloc (&r->s);
 157       if (! readline_read (&r->s, prompt_style))
 158         {
 159           *buf = '\n';
 160           fprintf (rl_outstream, "\n");
 161           return 1;
 162         }
 163       r->offset = 0;
 164       r->eof = ss_is_empty (r->s);
 165
 166       /* Check whether the size of the window has changed, so that
 167          the output drivers can adjust their settings as needed.  We
 168          only do this for the first line of a command, as it's
 169          possible that the output drivers are actually in use
 170          afterward, and we don't want to confuse them in the middle
 171          of output. */
 172       if (prompt_style == PROMPT_FIRST)
 173         terminal_check_size ();
 174     }
 175
 176   chunk = MIN (n, r->s.length - r->offset);
 177   memcpy (buf, r->s.string + r->offset, chunk);
 178   r->offset += chunk;
 179   return chunk;
 180 }
 181
 182 static void
 183 terminal_reader_close (struct lex_reader *r_)
 184 {
 185   struct terminal_reader *r = terminal_reader_cast (r_);
 186
 187   ss_dealloc (&r->s);
 188   free (r->reader.file_name);
 189   free (r);
 190
 191   if (!--n_terminal_readers)
 192     readline_done ();
 193 }
 194
 195 static struct lex_reader_class terminal_reader_class =
 196   {
 197     terminal_reader_read,
 198     terminal_reader_close
 199   };
 200
 201 /* Creates a source which uses readln to get its line */
 202 struct lex_reader *
 203 terminal_reader_create (void)
 204 {
 205   struct terminal_reader *r;
 206
 207   if (!n_terminal_readers++)
 208     readline_init ();
 209
 210   r = xzalloc (sizeof *r);
 211   r->reader.class = &terminal_reader_class;
 212   r->reader.syntax = LEX_SYNTAX_INTERACTIVE;
 213   r->reader.error = LEX_ERROR_TERMINAL;
 214   r->reader.file_name = NULL;
 215   r->s = ss_empty ();
 216   r->offset = 0;
 217   r->eof = false;
 218   return &r->reader;
 219 }
 220 \f
 221
 222
 223 static const char *
 224 readline_prompt (enum prompt_style style)
 225 {
 226   switch (style)
 227     {
 228     case PROMPT_FIRST:
 229       return "PSPP> ";
 230
 231     case PROMPT_LATER:
 232       return "    > ";
 233
 234     case PROMPT_DATA:
 235       return "data> ";
 236
 237     case PROMPT_COMMENT:
 238       return "comment> ";
 239
 240     case PROMPT_DOCUMENT:
 241       return "document> ";
 242
 243     case PROMPT_DO_REPEAT:
 244       return "DO REPEAT> ";
 245     }
 246
 247   NOT_REACHED ();
 248 }
 249
 250
 251
 252 static int pfd[2];
 253 static bool sigint_received ;
 254
 255 static void
 256 handler (int sig)
 257 {
 258   rl_end = 0;
 259
 260   write (pfd[1], "x", 1);
 261   rl_echo_signal_char (sig);
 262 }
 263
 264
 265 /*
 266    A function similar to getc from stdio.
 267    However this one may be interrupted by SIGINT.
 268    If that happens it will return EOF and the global variable
 269    sigint_received will be set to true.
 270  */
 271 static int
 272 interruptible_getc (FILE *fp)
 273 {
 274   int c  = 0;
 275   int ret = -1;
 276   do
 277     {
 278       struct timeval timeout = {0, 50000};
 279       fd_set what;
 280       int max_fd = 0;
 281       int fd ;
 282       FD_ZERO (&what);
 283       fd = fileno (fp);
 284       max_fd = (max_fd > fd) ? max_fd : fd;
 285       FD_SET (fd, &what);
 286       fd = pfd[0];
 287       max_fd = (max_fd > fd) ? max_fd : fd;
 288       FD_SET (fd, &what);
 289       ret = select (max_fd + 1, &what, NULL, NULL, &timeout);
 290       if ( ret == -1 && errno != EINTR)
 291         {
 292           perror ("Select failed");
 293           continue;
 294         }
 295
 296       if (ret > 0 )
 297         {
 298           if (FD_ISSET (pfd[0], &what))
 299             {
 300               char dummy[1];
 301               read (pfd[0], dummy, 1);
 302               sigint_received = true;
 303               return EOF;
 304             }
 305         }
 306     }
 307   while (ret <= 0);
 308
 309   /* This will not block! */
 310   read (fileno (fp), &c, 1);
 311
 312   return c;
 313 }
 314
 315
 316
 317 #if HAVE_READLINE
 318
 319 static void
 320 readline_init (void)
 321 {
 322   if ( 0 != pipe2 (pfd, O_NONBLOCK))
 323     perror ("Cannot create pipe");
 324
 325   if ( SIG_ERR == signal (SIGINT, handler))
 326     perror ("Cannot add signal handler");
 327
 328   rl_catch_signals = 0;
 329   rl_getc_function = interruptible_getc;
 330   rl_basic_word_break_characters = "\n";
 331   using_history ();
 332   stifle_history (500);
 333   if (history_file == NULL)
 334     {
 335       const char *home_dir = getenv ("HOME");
 336       if (home_dir != NULL)
 337         {
 338           history_file = xasprintf ("%s/.pspp_history", home_dir);
 339           read_history (history_file);
 340         }
 341     }
 342 }
 343
 344 static void
 345 readline_done (void)
 346 {
 347   if (history_file != NULL && false == settings_get_testing_mode () )
 348     write_history (history_file);
 349   clear_history ();
 350   free (history_file);
 351 }
 352
 353 /* Prompt the user for a line of input and return it in LINE.
 354    Returns true if the LINE should be considered valid, false otherwise.
 355  */
 356 static bool
 357 readline_read (struct substring *line, enum prompt_style style)
 358 {
 359   char *string;
 360
 361   rl_attempted_completion_function = (style == PROMPT_FIRST
 362                                       ? complete_command_name
 363                                       : dont_complete);
 364   sigint_received = false;
 365   string = readline (readline_prompt (style));
 366   if (sigint_received)
 367     {
 368       *line = ss_empty ();
 369       return false;
 370     }
 371
 372   if (string != NULL)
 373     {
 374       char *end;
 375
 376       if (string[0])
 377         add_history (string);
 378
 379       end = strchr (string, '\0');
 380       *end = '\n';
 381       *line = ss_buffer (string, end - string + 1);
 382     }
 383   else
 384     *line = ss_empty ();
 385
 386   return true;
 387 }
 388
 389 /* Returns a set of command name completions for TEXT.
 390    This is of the proper form for assigning to
 391    rl_attempted_completion_function. */
 392 static char **
 393 complete_command_name (const char *text, int start, int end UNUSED)
 394 {
 395   if (start == 0)
 396     {
 397       /* Complete command name at start of line. */
 398       return rl_completion_matches (text, command_generator);
 399     }
 400   else
 401     {
 402       /* Otherwise don't do any completion. */
 403       rl_attempted_completion_over = 1;
 404       return NULL;
 405     }
 406 }
 407
 408 /* Do not do any completion for TEXT. */
 409 static char **
 410 dont_complete (const char *text UNUSED, int start UNUSED, int end UNUSED)
 411 {
 412   rl_attempted_completion_over = 1;
 413   return NULL;
 414 }
 415
 416 /* If STATE is 0, returns the first command name matching TEXT.
 417    Otherwise, returns the next command name matching TEXT.
 418    Returns a null pointer when no matches are left. */
 419 static char *
 420 command_generator (const char *text, int state)
 421 {
 422   static const struct command *cmd;
 423   const char *name;
 424
 425   if (state == 0)
 426     cmd = NULL;
 427   name = cmd_complete (text, &cmd);
 428   return name ? xstrdup (name) : NULL;
 429 }
 430
 431 #else  /* !HAVE_READLINE */
 432
 433 static void
 434 readline_init (void)
 435 {
 436 }
 437
 438 static void
 439 readline_done (void)
 440 {
 441 }
 442
 443 static bool
 444 readline_read (struct substring *line, enum prompt_style style)
 445 {
 446   struct string string;
 447   const char *prompt = readline_prompt (style);
 448
 449   fputs (prompt, stdout);
 450   fflush (stdout);
 451   ds_init_empty (&string);
 452   ds_read_line (&string, stdin, SIZE_MAX);
 453
 454   *line = string.ss;
 455
 456   return false;
 457 }
 458 #endif /* !HAVE_READLINE */