contrib/libreadline/examples/rlfe/rlfe.c

   1 /* A front-end using readline to "cook" input lines.
   2  *
   3  * Copyright (C) 2004, 1999  Per Bothner
   4  *
   5  * This front-end program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as published
   7  * by the Free Software Foundation; either version 2, or (at your option)
   8  * any later version.
   9  *
  10  * Some code from Johnson & Troan: "Linux Application Development"
  11  * (Addison-Wesley, 1998) was used directly or for inspiration.
  12  *
  13  * 2003-11-07 Wolfgang Taeuber <wolfgang_taeuber@agilent.com>
  14  * Specify a history file and the size of the history file with command
  15  * line options; use EDITOR/VISUAL to set vi/emacs preference.
  16  */
  17
  18 /* PROBLEMS/TODO:
  19  *
  20  * Only tested under GNU/Linux and Mac OS 10.x;  needs to be ported.
  21  *
  22  * Switching between line-editing-mode vs raw-char-mode depending on
  23  * what tcgetattr returns is inherently not robust, plus it doesn't
  24  * work when ssh/telnetting in.  A better solution is possible if the
  25  * tty system can send in-line escape sequences indicating the current
  26  * mode, echo'd input, etc.  That would also allow a user preference
  27  * to set different colors for prompt, input, stdout, and stderr.
  28  *
  29  * When running mc -c under the Linux console, mc does not recognize
  30  * mouse clicks, which mc does when not running under rlfe.
  31  *
  32  * Pasting selected text containing tabs is like hitting the tab character,
  33  * which invokes readline completion.  We don't want this.  I don't know
  34  * if this is fixable without integrating rlfe into a terminal emulator.
  35  *
  36  * Echo suppression is a kludge, but can only be avoided with better kernel
  37  * support: We need a tty mode to disable "real" echoing, while still
  38  * letting the inferior think its tty driver to doing echoing.
  39  * Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE.
  40  *
  41  * The latest readline may have some hooks we can use to avoid having
  42  * to back up the prompt. (See HAVE_ALREADY_PROMPTED.)
  43  *
  44  * Desirable readline feature:  When in cooked no-echo mode (e.g. password),
  45  * echo characters are they are types with '*', but remove them when done.
  46  *
  47  * Asynchronous output while we're editing an input line should be
  48  * inserted in the output view *before* the input line, so that the
  49  * lines being edited (with the prompt) float at the end of the input.
  50  *
  51  * A "page mode" option to emulate more/less behavior:  At each page of
  52  * output, pause for a user command.  This required parsing the output
  53  * to keep track of line lengths.  It also requires remembering the
  54  * output, if we want an option to scroll back, which suggests that
  55  * this should be integrated with a terminal emulator like xterm.
  56  */
  57
  58 #include <stdio.h>
  59 #include <fcntl.h>
  60 #include <sys/types.h>
  61 #include <sys/socket.h>
  62 #include <netinet/in.h>
  63 #include <arpa/inet.h>
  64 #include <signal.h>
  65 #include <netdb.h>
  66 #include <stdlib.h>
  67 #include <errno.h>
  68 #include <grp.h>
  69 #include <string.h>
  70 #include <sys/stat.h>
  71 #include <unistd.h>
  72 #include <sys/ioctl.h>
  73 #include <termios.h>
  74
  75 #include "config.h"
  76
  77 #ifdef READLINE_LIBRARY
  78 #  include "readline.h"
  79 #  include "history.h"
  80 #else
  81 #  include <readline/readline.h>
  82 #  include <readline/history.h>
  83 #endif
  84
  85 #ifndef COMMAND
  86 #define COMMAND "/bin/bash"
  87 #endif
  88 #ifndef COMMAND_ARGS
  89 #define COMMAND_ARGS COMMAND
  90 #endif
  91
  92 #ifndef ALT_COMMAND
  93 #define ALT_COMMAND "/bin/sh"
  94 #endif
  95 #ifndef ALT_COMMAND_ARGS
  96 #define ALT_COMMAND_ARGS ALT_COMMAND
  97 #endif
  98
  99 #ifndef HAVE_MEMMOVE
 100 #  if __GNUC__ > 1
 101 #    define memmove(d, s, n)    __builtin_memcpy(d, s, n)
 102 #  else
 103 #    define memmove(d, s, n)    memcpy(d, s, n)
 104 #  endif
 105 #else
 106 #  define memmove(d, s, n)      memcpy(d, s, n)
 107 #endif
 108
 109 #define APPLICATION_NAME "rlfe"
 110
 111 static int in_from_inferior_fd;
 112 static int out_to_inferior_fd;
 113 static void set_edit_mode ();
 114 static void usage_exit ();
 115 static char *hist_file = 0;
 116 static int  hist_size = 0;
 117
 118 /* Unfortunately, we cannot safely display echo from the inferior process.
 119    The reason is that the echo bit in the pty is "owned" by the inferior,
 120    and if we try to turn it off, we could confuse the inferior.
 121    Thus, when echoing, we get echo twice:  First readline echoes while
 122    we're actually editing. Then we send the line to the inferior, and the
 123    terminal driver send back an extra echo.
 124    The work-around is to remember the input lines, and when we see that
 125    line come back, we supress the output.
 126    A better solution (supposedly available on SVR4) would be a smarter
 127    terminal driver, with more flags ... */
 128 #define ECHO_SUPPRESS_MAX 1024
 129 char echo_suppress_buffer[ECHO_SUPPRESS_MAX];
 130 int echo_suppress_start = 0;
 131 int echo_suppress_limit = 0;
 132
 133 /*#define DEBUG*/
 134
 135 #ifdef DEBUG
 136 FILE *logfile = NULL;
 137 #define DPRINT0(FMT) (fprintf(logfile, FMT), fflush(logfile))
 138 #define DPRINT1(FMT, V1) (fprintf(logfile, FMT, V1), fflush(logfile))
 139 #define DPRINT2(FMT, V1, V2) (fprintf(logfile, FMT, V1, V2), fflush(logfile))
 140 #else
 141 #define DPRINT0(FMT) ((void) 0) /* Do nothing */
 142 #define DPRINT1(FMT, V1) ((void) 0) /* Do nothing */
 143 #define DPRINT2(FMT, V1, V2) ((void) 0) /* Do nothing */
 144 #endif
 145
 146 struct termios orig_term;
 147
 148 /* Pid of child process. */
 149 static pid_t child = -1;
 150
 151 static void
 152 sig_child (int signo)
 153 {
 154   int status;
 155   wait (&status);
 156   if (hist_file != 0)
 157     {
 158       write_history (hist_file);
 159       if (hist_size)
 160         history_truncate_file (hist_file, hist_size);
 161     }
 162   DPRINT0 ("(Child process died.)\n");
 163   tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
 164   exit (0);
 165 }
 166
 167 volatile int propagate_sigwinch = 0;
 168
 169 /* sigwinch_handler
 170  * propagate window size changes from input file descriptor to
 171  * master side of pty.
 172  */
 173 void sigwinch_handler(int signal) {
 174    propagate_sigwinch = 1;
 175 }
 176
 177
 178 /* get_slave_pty() returns an integer file descriptor.
 179  * If it returns < 0, an error has occurred.
 180  * Otherwise, it has returned the slave file descriptor.
 181  */
 182
 183 int get_slave_pty(char *name) {
 184    struct group *gptr;
 185    gid_t gid;
 186    int slave = -1;
 187
 188    /* chown/chmod the corresponding pty, if possible.
 189     * This will only work if the process has root permissions.
 190     * Alternatively, write and exec a small setuid program that
 191     * does just this.
 192     */
 193    if ((gptr = getgrnam("tty")) != 0) {
 194       gid = gptr->gr_gid;
 195    } else {
 196       /* if the tty group does not exist, don't change the
 197        * group on the slave pty, only the owner
 198        */
 199       gid = -1;
 200    }
 201
 202    /* Note that we do not check for errors here.  If this is code
 203     * where these actions are critical, check for errors!
 204     */
 205    chown(name, getuid(), gid);
 206    /* This code only makes the slave read/writeable for the user.
 207     * If this is for an interactive shell that will want to
 208     * receive "write" and "wall" messages, OR S_IWGRP into the
 209     * second argument below.
 210     */
 211    chmod(name, S_IRUSR|S_IWUSR);
 212
 213    /* open the corresponding slave pty */
 214    slave = open(name, O_RDWR);
 215    return (slave);
 216 }
 217
 218 /* Certain special characters, such as ctrl/C, we want to pass directly
 219    to the inferior, rather than letting readline handle them. */
 220
 221 static char special_chars[20];
 222 static int special_chars_count;
 223
 224 static void
 225 add_special_char(int ch)
 226 {
 227   if (ch != 0)
 228     special_chars[special_chars_count++] = ch;
 229 }
 230
 231 static int eof_char;
 232
 233 static int
 234 is_special_char(int ch)
 235 {
 236   int i;
 237 #if 0
 238   if (ch == eof_char && rl_point == rl_end)
 239     return 1;
 240 #endif
 241   for (i = special_chars_count;  --i >= 0; )
 242     if (special_chars[i] == ch)
 243       return 1;
 244   return 0;
 245 }
 246
 247 static char buf[1024];
 248 /* buf[0 .. buf_count-1] is the what has been emitted on the current line.
 249    It is used as the readline prompt. */
 250 static int buf_count = 0;
 251
 252 int do_emphasize_input = 1;
 253 int current_emphasize_input;
 254
 255 char *start_input_mode = "\033[1m";
 256 char *end_input_mode = "\033[0m";
 257
 258 int num_keys = 0;
 259
 260 static void maybe_emphasize_input (int on)
 261 {
 262   if (on == current_emphasize_input
 263       || (on && ! do_emphasize_input))
 264     return;
 265   fprintf (rl_outstream, on ? start_input_mode : end_input_mode);
 266   fflush (rl_outstream);
 267   current_emphasize_input = on;
 268 }
 269
 270 static void
 271 null_prep_terminal (int meta)
 272 {
 273 }
 274
 275 static void
 276 null_deprep_terminal ()
 277 {
 278   maybe_emphasize_input (0);
 279 }
 280
 281 static int
 282 pre_input_change_mode (void)
 283 {
 284   return 0;
 285 }
 286
 287 char pending_special_char;
 288
 289 static void
 290 line_handler (char *line)
 291 {
 292   if (line == NULL)
 293     {
 294       char buf[1];
 295       DPRINT0("saw eof!\n");
 296       buf[0] = '\004'; /* ctrl/d */
 297       write (out_to_inferior_fd, buf, 1);
 298     }
 299   else
 300     {
 301       static char enter[] = "\r";
 302       /*  Send line to inferior: */
 303       int length = strlen (line);
 304       if (length > ECHO_SUPPRESS_MAX-2)
 305         {
 306           echo_suppress_start = 0;
 307           echo_suppress_limit = 0;
 308         }
 309       else
 310         {
 311           if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2)
 312             {
 313               if (echo_suppress_limit - echo_suppress_start + length
 314                   <= ECHO_SUPPRESS_MAX - 2)
 315                 {
 316                   memmove (echo_suppress_buffer,
 317                            echo_suppress_buffer + echo_suppress_start,
 318                            echo_suppress_limit - echo_suppress_start);
 319                   echo_suppress_limit -= echo_suppress_start;
 320                   echo_suppress_start = 0;
 321                 }
 322               else
 323                 {
 324                   echo_suppress_limit = 0;
 325                 }
 326               echo_suppress_start = 0;
 327             }
 328           memcpy (echo_suppress_buffer + echo_suppress_limit,
 329                   line, length);
 330           echo_suppress_limit += length;
 331           echo_suppress_buffer[echo_suppress_limit++] = '\r';
 332           echo_suppress_buffer[echo_suppress_limit++] = '\n';
 333         }
 334       write (out_to_inferior_fd, line, length);
 335       if (pending_special_char == 0)
 336         {
 337           write (out_to_inferior_fd, enter, sizeof(enter)-1);
 338           if (*line)
 339             add_history (line);
 340         }
 341       free (line);
 342     }
 343   rl_callback_handler_remove ();
 344   buf_count = 0;
 345   num_keys = 0;
 346   if (pending_special_char != 0)
 347     {
 348       write (out_to_inferior_fd, &pending_special_char, 1);
 349       pending_special_char = 0;
 350     }
 351 }
 352
 353 /* Value of rl_getc_function.
 354    Use this because readline should read from stdin, not rl_instream,
 355    points to the pty (so readline has monitor its terminal modes). */
 356
 357 int
 358 my_rl_getc (FILE *dummy)
 359 {
 360   int ch = rl_getc (stdin);
 361   if (is_special_char (ch))
 362     {
 363       pending_special_char = ch;
 364       return '\r';
 365     }
 366   return ch;
 367 }
 368
 369 int
 370 main(int argc, char** argv)
 371 {
 372   char *path;
 373   int i;
 374   int master;
 375   char *name;
 376   int in_from_tty_fd;
 377   struct sigaction act;
 378   struct winsize ws;
 379   struct termios t;
 380   int maxfd;
 381   fd_set in_set;
 382   static char empty_string[1] = "";
 383   char *prompt = empty_string;
 384   int ioctl_err = 0;
 385   int arg_base = 1;
 386
 387 #ifdef DEBUG
 388   logfile = fopen("/tmp/rlfe.log", "w");
 389 #endif
 390
 391   while (arg_base<argc)
 392     {
 393       if (argv[arg_base][0] != '-')
 394         break;
 395       if (arg_base+1 >= argc )
 396         usage_exit();
 397       switch(argv[arg_base][1])
 398         {
 399         case 'h':
 400           arg_base++;
 401           hist_file = argv[arg_base];
 402           break;
 403         case 's':
 404           arg_base++;
 405           hist_size = atoi(argv[arg_base]);
 406           if (hist_size<0)
 407             usage_exit();
 408           break;
 409         default:
 410           usage_exit();
 411         }
 412       arg_base++;
 413     }
 414   if (hist_file)
 415     read_history (hist_file);
 416
 417   set_edit_mode ();
 418
 419   rl_readline_name = APPLICATION_NAME;
 420
 421   if ((master = OpenPTY (&name)) < 0)
 422     {
 423       perror("ptypair: could not open master pty");
 424       exit(1);
 425     }
 426
 427   DPRINT1("pty name: '%s'\n", name);
 428
 429   /* set up SIGWINCH handler */
 430   act.sa_handler = sigwinch_handler;
 431   sigemptyset(&(act.sa_mask));
 432   act.sa_flags = 0;
 433   if (sigaction(SIGWINCH, &act, NULL) < 0)
 434     {
 435       perror("ptypair: could not handle SIGWINCH ");
 436       exit(1);
 437     }
 438
 439   if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
 440     {
 441       perror("ptypair: could not get window size");
 442       exit(1);
 443     }
 444
 445   if ((child = fork()) < 0)
 446     {
 447       perror("cannot fork");
 448       exit(1);
 449     }
 450
 451   if (child == 0)
 452     {
 453       int slave;  /* file descriptor for slave pty */
 454
 455       /* We are in the child process */
 456       close(master);
 457
 458 #ifdef TIOCSCTTY
 459       if ((slave = get_slave_pty(name)) < 0)
 460         {
 461           perror("ptypair: could not open slave pty");
 462           exit(1);
 463         }
 464 #endif
 465
 466       /* We need to make this process a session group leader, because
 467        * it is on a new PTY, and things like job control simply will
 468        * not work correctly unless there is a session group leader
 469        * and process group leader (which a session group leader
 470        * automatically is). This also disassociates us from our old
 471        * controlling tty.
 472        */
 473       if (setsid() < 0)
 474         {
 475           perror("could not set session leader");
 476         }
 477
 478       /* Tie us to our new controlling tty. */
 479 #ifdef TIOCSCTTY
 480       if (ioctl(slave, TIOCSCTTY, NULL))
 481         {
 482           perror("could not set new controlling tty");
 483         }
 484 #else
 485       if ((slave = get_slave_pty(name)) < 0)
 486         {
 487           perror("ptypair: could not open slave pty");
 488           exit(1);
 489         }
 490 #endif
 491
 492       /* make slave pty be standard in, out, and error */
 493       dup2(slave, STDIN_FILENO);
 494       dup2(slave, STDOUT_FILENO);
 495       dup2(slave, STDERR_FILENO);
 496
 497       /* at this point the slave pty should be standard input */
 498       if (slave > 2)
 499         {
 500           close(slave);
 501         }
 502
 503       /* Try to restore window size; failure isn't critical */
 504       if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0)
 505         {
 506           perror("could not restore window size");
 507         }
 508
 509       /* now start the shell */
 510       {
 511         static char* command_args[] = { COMMAND_ARGS, NULL };
 512         static char* alt_command_args[] = { ALT_COMMAND_ARGS, NULL };
 513         if (argc <= 1)
 514           {
 515             execvp (COMMAND, command_args);
 516             execvp (ALT_COMMAND, alt_command_args);
 517           }
 518         else
 519           execvp (argv[arg_base], &argv[arg_base]);
 520       }
 521
 522       /* should never be reached */
 523       exit(1);
 524     }
 525
 526   /* parent */
 527   signal (SIGCHLD, sig_child);
 528
 529   /* Note that we only set termios settings for standard input;
 530    * the master side of a pty is NOT a tty.
 531    */
 532   tcgetattr(STDIN_FILENO, &orig_term);
 533
 534   t = orig_term;
 535   eof_char = t.c_cc[VEOF];
 536   /*  add_special_char(t.c_cc[VEOF]);*/
 537   add_special_char(t.c_cc[VINTR]);
 538   add_special_char(t.c_cc[VQUIT]);
 539   add_special_char(t.c_cc[VSUSP]);
 540 #if defined (VDISCARD)
 541   add_special_char(t.c_cc[VDISCARD]);
 542 #endif
 543
 544   t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \
 545                  ECHOK | ECHOKE | ECHONL | ECHOPRT );
 546   t.c_iflag &= ~ICRNL;
 547   t.c_iflag |= IGNBRK;
 548   t.c_cc[VMIN] = 1;
 549   t.c_cc[VTIME] = 0;
 550   tcsetattr(STDIN_FILENO, TCSANOW, &t);
 551   in_from_inferior_fd = master;
 552   out_to_inferior_fd = master;
 553   rl_instream = fdopen (master, "r");
 554   rl_getc_function = my_rl_getc;
 555
 556   rl_prep_term_function = null_prep_terminal;
 557   rl_deprep_term_function = null_deprep_terminal;
 558   rl_pre_input_hook = pre_input_change_mode;
 559   rl_callback_handler_install (prompt, line_handler);
 560
 561   in_from_tty_fd = STDIN_FILENO;
 562   FD_ZERO (&in_set);
 563   maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd
 564     : in_from_tty_fd;
 565   for (;;)
 566     {
 567       int num;
 568       FD_SET (in_from_inferior_fd, &in_set);
 569       FD_SET (in_from_tty_fd, &in_set);
 570
 571       num = select(maxfd+1, &in_set, NULL, NULL, NULL);
 572
 573       if (propagate_sigwinch)
 574         {
 575           struct winsize ws;
 576           if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
 577             {
 578               ioctl (master, TIOCSWINSZ, &ws);
 579             }
 580           propagate_sigwinch = 0;
 581           continue;
 582         }
 583
 584       if (num <= 0)
 585         {
 586           perror ("select");
 587           exit (-1);
 588         }
 589       if (FD_ISSET (in_from_tty_fd, &in_set))
 590         {
 591           extern int readline_echoing_p;
 592           struct termios term_master;
 593           int do_canon = 1;
 594           int do_icrnl = 1;
 595           int ioctl_ret;
 596
 597           DPRINT1("[tty avail num_keys:%d]\n", num_keys);
 598
 599           /* If we can't get tty modes for the master side of the pty, we
 600              can't handle non-canonical-mode programs.  Always assume the
 601              master is in canonical echo mode if we can't tell. */
 602           ioctl_ret = tcgetattr(master, &term_master);
 603
 604           if (ioctl_ret >= 0)
 605             {
 606               do_canon = (term_master.c_lflag & ICANON) != 0;
 607               do_icrnl = (term_master.c_lflag & ICRNL) != 0;
 608               readline_echoing_p = (term_master.c_lflag & ECHO) != 0;
 609               DPRINT1 ("echo,canon,crnl:%03d\n",
 610                        100 * readline_echoing_p
 611                        + 10 * do_canon
 612                        + 1 * do_icrnl);
 613             }
 614           else
 615             {
 616               if (ioctl_err == 0)
 617                 DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno);
 618               ioctl_err = 1;
 619             }
 620
 621           if (do_canon == 0 && num_keys == 0)
 622             {
 623               char ch[10];
 624               int count = read (STDIN_FILENO, ch, sizeof(ch));
 625               DPRINT1("[read %d chars from stdin: ", count);
 626               DPRINT2(" \"%.*s\"]\n", count, ch);
 627               if (do_icrnl)
 628                 {
 629                   int i = count;
 630                   while (--i >= 0)
 631                     {
 632                       if (ch[i] == '\r')
 633                         ch[i] = '\n';
 634                     }
 635                 }
 636               maybe_emphasize_input (1);
 637               write (out_to_inferior_fd, ch, count);
 638             }
 639           else
 640             {
 641               if (num_keys == 0)
 642                 {
 643                   int i;
 644                   /* Re-install callback handler for new prompt. */
 645                   if (prompt != empty_string)
 646                     free (prompt);
 647                   if (prompt == NULL)
 648                     {
 649                       DPRINT0("New empty prompt\n");
 650                       prompt = empty_string;
 651                     }
 652                   else
 653                     {
 654                       if (do_emphasize_input && buf_count > 0)
 655                         {
 656                           prompt = malloc (buf_count + strlen (end_input_mode)
 657                                            + strlen (start_input_mode) + 5);
 658                           sprintf (prompt, "\001%s\002%.*s\001%s\002",
 659                                    end_input_mode,
 660                                    buf_count, buf,
 661                                    start_input_mode);
 662                         }
 663                       else
 664                         {
 665                           prompt = malloc (buf_count + 1);
 666                           memcpy (prompt, buf, buf_count);
 667                           prompt[buf_count] = '\0';
 668                         }
 669                       DPRINT1("New prompt '%s'\n", prompt);
 670 #if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED */
 671                       /* Doesn't quite work when do_emphasize_input is 1. */
 672                       rl_already_prompted = buf_count > 0;
 673 #else
 674                       if (buf_count > 0)
 675                         write (1, "\r", 1);
 676 #endif
 677                     }
 678
 679                   rl_callback_handler_install (prompt, line_handler);
 680                 }
 681               num_keys++;
 682               maybe_emphasize_input (1);
 683               rl_callback_read_char ();
 684             }
 685         }
 686       else /* output from inferior. */
 687         {
 688           int i;
 689           int count;
 690           int old_count;
 691           if (buf_count > (sizeof(buf) >> 2))
 692             buf_count = 0;
 693           count = read (in_from_inferior_fd, buf+buf_count,
 694                         sizeof(buf) - buf_count);
 695           DPRINT2("read %d from inferior, buf_count=%d", count, buf_count);
 696           DPRINT2(": \"%.*s\"", count, buf+buf_count);
 697           maybe_emphasize_input (0);
 698           if (count <= 0)
 699             {
 700               DPRINT0 ("(Connection closed by foreign host.)\n");
 701               tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
 702               exit (0);
 703             }
 704           old_count = buf_count;
 705
 706           /* Look for any pending echo that we need to suppress. */
 707           while (echo_suppress_start < echo_suppress_limit
 708                  && count > 0
 709                  && buf[buf_count] == echo_suppress_buffer[echo_suppress_start])
 710             {
 711               count--;
 712               buf_count++;
 713               echo_suppress_start++;
 714             }
 715           DPRINT1("suppressed %d characters of echo.\n", buf_count-old_count);
 716
 717           /* Write to the terminal anything that was not suppressed. */
 718           if (count > 0)
 719             write (1, buf + buf_count, count);
 720
 721           /* Finally, look for a prompt candidate.
 722            * When we get around to going input (from the keyboard),
 723            * we will consider the prompt to be anything since the last
 724            * line terminator.  So we need to save that text in the
 725            * initial part of buf.  However, anything before the
 726            * most recent end-of-line is not interesting. */
 727           buf_count += count;
 728 #if 1
 729           for (i = buf_count;  --i >= old_count; )
 730 #else
 731           for (i = buf_count - 1;  i-- >= buf_count - count; )
 732 #endif
 733             {
 734               if (buf[i] == '\n' || buf[i] == '\r')
 735                 {
 736                   i++;
 737                   memmove (buf, buf+i, buf_count - i);
 738                   buf_count -= i;
 739                   break;
 740                 }
 741             }
 742           DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count);
 743         }
 744     }
 745 }
 746
 747 static void set_edit_mode ()
 748 {
 749   int vi = 0;
 750   char *shellopts;
 751
 752   shellopts = getenv ("SHELLOPTS");
 753   while (shellopts != 0)
 754     {
 755       if (strncmp ("vi", shellopts, 2) == 0)
 756         {
 757           vi = 1;
 758           break;
 759         }
 760       shellopts = index (shellopts + 1, ':');
 761     }
 762
 763   if (!vi)
 764     {
 765       if (getenv ("EDITOR") != 0)
 766         vi |= strcmp (getenv ("EDITOR"), "vi") == 0;
 767     }
 768
 769   if (vi)
 770     rl_variable_bind ("editing-mode", "vi");
 771   else
 772     rl_variable_bind ("editing-mode", "emacs");
 773 }
 774
 775
 776 static void usage_exit ()
 777 {
 778   fprintf (stderr, "Usage: rlfe [-h histfile] [-s size] cmd [arg1] [arg2] ...\n\n");
 779   exit (1);
 780 }