readline/readline.c

   1 /* readline.c -- a general facility for reading lines of input
   2    with emacs style editing and completion. */
   3
   4 /* Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
   5
   6    This file contains the Readline Library (the Library), a set of
   7    routines for providing Emacs style line input to programs that ask
   8    for it.
   9
  10    The Library is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    The Library is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 /* Remove these declarations when we have a complete libgnu.a. */
  25 /* #define STATIC_MALLOC */
  26 #if !defined (STATIC_MALLOC)
  27 extern char *xmalloc (), *xrealloc ();
  28 #else
  29 static char *xmalloc (), *xrealloc ();
  30 #endif /* STATIC_MALLOC */
  31
  32 #include "sysdep.h"
  33 #include <sys/types.h>
  34 #include <stdio.h>
  35 #include <fcntl.h>
  36 #ifndef NO_SYS_FILE
  37 #include <sys/file.h>
  38 #endif
  39 #include <signal.h>
  40
  41 #if defined (HAVE_UNISTD_H)
  42 #  include <unistd.h>
  43 #endif
  44
  45 #define NEW_TTY_DRIVER
  46 #define HAVE_BSD_SIGNALS
  47 /* #define USE_XON_XOFF */
  48
  49 #ifdef __MSDOS__
  50 #undef NEW_TTY_DRIVER
  51 #undef HAVE_BSD_SIGNALS
  52 #endif
  53
  54 /* Some USG machines have BSD signal handling (sigblock, sigsetmask, etc.) */
  55 #if defined (USG) && !defined (hpux)
  56 #undef HAVE_BSD_SIGNALS
  57 #endif
  58
  59 /* System V machines use termio. */
  60 #if !defined (_POSIX_VERSION)
  61 #  if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi) || defined (DGUX)
  62 #    undef NEW_TTY_DRIVER
  63 #    define TERMIO_TTY_DRIVER
  64 #    include <termio.h>
  65 #    if !defined (TCOON)
  66 #      define TCOON 1
  67 #    endif
  68 #  endif /* USG || hpux || Xenix || sgi || DUGX */
  69 #endif /* !_POSIX_VERSION */
  70
  71 /* Posix systems use termios and the Posix signal functions. */
  72 #if defined (_POSIX_VERSION)
  73 #  if !defined (TERMIOS_MISSING)
  74 #    undef NEW_TTY_DRIVER
  75 #    define TERMIOS_TTY_DRIVER
  76 #    include <termios.h>
  77 #  endif /* !TERMIOS_MISSING */
  78 #  define HAVE_POSIX_SIGNALS
  79 #  if !defined (O_NDELAY)
  80 #    define O_NDELAY O_NONBLOCK /* Posix-style non-blocking i/o */
  81 #  endif /* O_NDELAY */
  82 #endif /* _POSIX_VERSION */
  83
  84 /* Other (BSD) machines use sgtty. */
  85 #if defined (NEW_TTY_DRIVER)
  86 #include <sgtty.h>
  87 #endif
  88
  89 /* Define _POSIX_VDISABLE if we are not using the `new' tty driver and
  90    it is not already defined.  It is used both to determine if a
  91    special character is disabled and to disable certain special
  92    characters.  Posix systems should set to 0, USG systems to -1. */
  93 #if !defined (NEW_TTY_DRIVER) && !defined (_POSIX_VDISABLE)
  94 #  if defined (_POSIX_VERSION)
  95 #    define _POSIX_VDISABLE 0
  96 #  else /* !_POSIX_VERSION */
  97 #    define _POSIX_VDISABLE -1
  98 #  endif /* !_POSIX_VERSION */
  99 #endif /* !NEW_TTY_DRIVER && !_POSIX_VDISABLE */
 100
 101 #include <errno.h>
 102 extern int errno;
 103
 104 #include <setjmp.h>
 105 #include <sys/stat.h>
 106
 107 /* Posix macro to check file in statbuf for directory-ness. */
 108 #if defined (S_IFDIR) && !defined (S_ISDIR)
 109 #define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
 110 #endif
 111
 112 #ifndef __MSDOS__
 113 /* These next are for filename completion.  Perhaps this belongs
 114    in a different place. */
 115 #include <pwd.h>
 116 #endif /* __MSDOS__ */
 117
 118 #if defined (USG) && !defined (isc386) && !defined (sgi)
 119 struct passwd *getpwuid (), *getpwent ();
 120 #endif
 121
 122 /* #define HACK_TERMCAP_MOTION */
 123
 124 /* Some standard library routines. */
 125 #include "readline.h"
 126 #include "history.h"
 127
 128 #ifndef digit
 129 #define digit(c)  ((c) >= '0' && (c) <= '9')
 130 #endif
 131
 132 #ifndef isletter
 133 #define isletter(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
 134 #endif
 135
 136 #ifndef digit_value
 137 #define digit_value(c) ((c) - '0')
 138 #endif
 139
 140 #ifndef member
 141 #define member(c, s) ((c) ? index ((s), (c)) : 0)
 142 #endif
 143
 144 #ifndef isident
 145 #define isident(c) ((isletter(c) || digit(c) || c == '_'))
 146 #endif
 147
 148 #ifndef exchange
 149 #define exchange(x, y) {int temp = x; x = y; y = temp;}
 150 #endif
 151
 152 #if !defined (rindex)
 153 extern char *rindex ();
 154 #endif /* rindex */
 155
 156 #if !defined (index)
 157 extern char *index ();
 158 #endif /* index */
 159
 160 extern char *getenv ();
 161 extern char *tilde_expand ();
 162
 163 static update_line ();
 164 static void output_character_function ();
 165 static delete_chars ();
 166 static insert_some_chars ();
 167
 168 #if defined (VOID_SIGHANDLER)
 169 #  define sighandler void
 170 #else
 171 #  define sighandler int
 172 #endif /* VOID_SIGHANDLER */
 173
 174 /* This typedef is equivalant to the one for Function; it allows us
 175    to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
 176 typedef sighandler SigHandler ();
 177
 178 /* If on, then readline handles signals in a way that doesn't screw. */
 179 #define HANDLE_SIGNALS
 180
 181 #ifdef __GO32__
 182 #include <sys/pc.h>
 183 #undef HANDLE_SIGNALS
 184 #endif
 185
 186 \f
 187 /* **************************************************************** */
 188 /*                                                                  */
 189 /*                      Line editing input utility                  */
 190 /*                                                                  */
 191 /* **************************************************************** */
 192
 193 /* A pointer to the keymap that is currently in use.
 194    By default, it is the standard emacs keymap. */
 195 Keymap keymap = emacs_standard_keymap;
 196
 197 #define no_mode -1
 198 #define vi_mode 0
 199 #define emacs_mode 1
 200
 201 /* The current style of editing. */
 202 int rl_editing_mode = emacs_mode;
 203
 204 /* Non-zero if the previous command was a kill command. */
 205 static int last_command_was_kill = 0;
 206
 207 /* The current value of the numeric argument specified by the user. */
 208 int rl_numeric_arg = 1;
 209
 210 /* Non-zero if an argument was typed. */
 211 int rl_explicit_arg = 0;
 212
 213 /* Temporary value used while generating the argument. */
 214 int rl_arg_sign = 1;
 215
 216 /* Non-zero means we have been called at least once before. */
 217 static int rl_initialized = 0;
 218
 219 /* If non-zero, this program is running in an EMACS buffer. */
 220 static char *running_in_emacs = (char *)NULL;
 221
 222 /* The current offset in the current input line. */
 223 int rl_point;
 224
 225 /* Mark in the current input line. */
 226 int rl_mark;
 227
 228 /* Length of the current input line. */
 229 int rl_end;
 230
 231 /* Make this non-zero to return the current input_line. */
 232 int rl_done;
 233
 234 /* The last function executed by readline. */
 235 Function *rl_last_func = (Function *)NULL;
 236
 237 /* Top level environment for readline_internal (). */
 238 static jmp_buf readline_top_level;
 239
 240 /* The streams we interact with. */
 241 static FILE *in_stream, *out_stream;
 242
 243 /* The names of the streams that we do input and output to. */
 244 FILE *rl_instream, *rl_outstream;
 245
 246 /* Non-zero means echo characters as they are read. */
 247 int readline_echoing_p = 1;
 248
 249 /* Current prompt. */
 250 char *rl_prompt;
 251
 252 /* The number of characters read in order to type this complete command. */
 253 int rl_key_sequence_length = 0;
 254
 255 /* If non-zero, then this is the address of a function to call just
 256    before readline_internal () prints the first prompt. */
 257 Function *rl_startup_hook = (Function *)NULL;
 258
 259 /* If non-zero, then this is the address of a function to call when
 260    completing on a directory name.  The function is called with
 261    the address of a string (the current directory name) as an arg. */
 262 Function *rl_symbolic_link_hook = (Function *)NULL;
 263
 264 /* What we use internally.  You should always refer to RL_LINE_BUFFER. */
 265 static char *the_line;
 266
 267 /* The character that can generate an EOF.  Really read from
 268    the terminal driver... just defaulted here. */
 269 static int eof_char = CTRL ('D');
 270
 271 /* Non-zero makes this the next keystroke to read. */
 272 int rl_pending_input = 0;
 273
 274 /* Pointer to a useful terminal name. */
 275 char *rl_terminal_name = (char *)NULL;
 276
 277 /* Line buffer and maintenence. */
 278 char *rl_line_buffer = (char *)NULL;
 279 int rl_line_buffer_len = 0;
 280 #define DEFAULT_BUFFER_SIZE 256
 281
 282 \f
 283 /* **************************************************************** */
 284 /*                                                                  */
 285 /*                      `Forward' declarations                      */
 286 /*                                                                  */
 287 /* **************************************************************** */
 288
 289 /* Non-zero means do not parse any lines other than comments and
 290    parser directives. */
 291 static unsigned char parsing_conditionalized_out = 0;
 292
 293 /* Caseless strcmp (). */
 294 static int stricmp (), strnicmp ();
 295 static char *strpbrk ();
 296
 297 /* Non-zero means to save keys that we dispatch on in a kbd macro. */
 298 static int defining_kbd_macro = 0;
 299
 300 \f
 301 /* **************************************************************** */
 302 /*                                                                  */
 303 /*                      Top Level Functions                         */
 304 /*                                                                  */
 305 /* **************************************************************** */
 306
 307 static void rl_prep_terminal (), rl_deprep_terminal ();
 308
 309 /* Read a line of input.  Prompt with PROMPT.  A NULL PROMPT means
 310    none.  A return value of NULL means that EOF was encountered. */
 311 char *
 312 readline (prompt)
 313      char *prompt;
 314 {
 315   char *readline_internal ();
 316   char *value;
 317
 318   rl_prompt = prompt;
 319
 320   /* If we are at EOF return a NULL string. */
 321   if (rl_pending_input == EOF)
 322     {
 323       rl_pending_input = 0;
 324       return ((char *)NULL);
 325     }
 326
 327   rl_initialize ();
 328   rl_prep_terminal ();
 329
 330 #if defined (HANDLE_SIGNALS)
 331   rl_set_signals ();
 332 #endif
 333
 334   value = readline_internal ();
 335   rl_deprep_terminal ();
 336
 337 #if defined (HANDLE_SIGNALS)
 338   rl_clear_signals ();
 339 #endif
 340
 341   return (value);
 342 }
 343
 344 /* Read a line of input from the global rl_instream, doing output on
 345    the global rl_outstream.
 346    If rl_prompt is non-null, then that is our prompt. */
 347 char *
 348 readline_internal ()
 349 {
 350   int lastc, c, eof_found;
 351
 352   in_stream  = rl_instream;
 353   out_stream = rl_outstream;
 354
 355   lastc = -1;
 356   eof_found = 0;
 357
 358   if (rl_startup_hook)
 359     (*rl_startup_hook) ();
 360
 361   if (!readline_echoing_p)
 362     {
 363       if (rl_prompt)
 364         {
 365           fprintf (out_stream, "%s", rl_prompt);
 366           fflush (out_stream);
 367         }
 368     }
 369   else
 370     {
 371       rl_on_new_line ();
 372       rl_redisplay ();
 373 #if defined (VI_MODE)
 374       if (rl_editing_mode == vi_mode)
 375         rl_vi_insertion_mode ();
 376 #endif /* VI_MODE */
 377     }
 378
 379   while (!rl_done)
 380     {
 381       int lk = last_command_was_kill;
 382       int code = setjmp (readline_top_level);
 383
 384       if (code)
 385         rl_redisplay ();
 386
 387       if (!rl_pending_input)
 388         {
 389           /* Then initialize the argument and number of keys read. */
 390           rl_init_argument ();
 391           rl_key_sequence_length = 0;
 392         }
 393
 394       c = rl_read_key ();
 395
 396       /* EOF typed to a non-blank line is a <NL>. */
 397       if (c == EOF && rl_end)
 398         c = NEWLINE;
 399
 400       /* The character eof_char typed to blank line, and not as the
 401          previous character is interpreted as EOF. */
 402       if (((c == eof_char && lastc != c) || c == EOF) && !rl_end)
 403         {
 404           eof_found = 1;
 405           break;
 406         }
 407
 408       lastc = c;
 409       rl_dispatch (c, keymap);
 410
 411       /* If there was no change in last_command_was_kill, then no kill
 412          has taken place.  Note that if input is pending we are reading
 413          a prefix command, so nothing has changed yet. */
 414       if (!rl_pending_input)
 415         {
 416           if (lk == last_command_was_kill)
 417             last_command_was_kill = 0;
 418         }
 419
 420 #if defined (VI_MODE)
 421       /* In vi mode, when you exit insert mode, the cursor moves back
 422          over the previous character.  We explicitly check for that here. */
 423       if (rl_editing_mode == vi_mode && keymap == vi_movement_keymap)
 424         rl_vi_check ();
 425 #endif /* VI_MODE */
 426
 427       if (!rl_done)
 428         rl_redisplay ();
 429     }
 430
 431   /* Restore the original of this history line, iff the line that we
 432      are editing was originally in the history, AND the line has changed. */
 433   {
 434     HIST_ENTRY *entry = current_history ();
 435
 436     if (entry && rl_undo_list)
 437       {
 438         char *temp = savestring (the_line);
 439         rl_revert_line ();
 440         entry = replace_history_entry (where_history (), the_line,
 441                                        (HIST_ENTRY *)NULL);
 442         free_history_entry (entry);
 443
 444         strcpy (the_line, temp);
 445         free (temp);
 446       }
 447   }
 448
 449   /* At any rate, it is highly likely that this line has an undo list.  Get
 450      rid of it now. */
 451   if (rl_undo_list)
 452     free_undo_list ();
 453
 454   if (eof_found)
 455     return (char *)NULL;
 456   else
 457     return (savestring (the_line));
 458 }
 459
 460 \f
 461 /* **************************************************************** */
 462 /*                                                                  */
 463 /*                         Signal Handling                          */
 464 /*                                                                  */
 465 /* **************************************************************** */
 466
 467 #if defined (SIGWINCH)
 468 static SigHandler *old_sigwinch = (SigHandler *)NULL;
 469
 470 static sighandler
 471 rl_handle_sigwinch (sig)
 472      int sig;
 473 {
 474   char *term;
 475
 476   term = rl_terminal_name;
 477
 478   if (readline_echoing_p)
 479     {
 480       if (!term)
 481         term = getenv ("TERM");
 482       if (!term)
 483         term = "dumb";
 484       rl_reset_terminal (term);
 485 #if defined (NOTDEF)
 486       crlf ();
 487       rl_forced_update_display ();
 488 #endif /* NOTDEF */
 489     }
 490
 491   if (old_sigwinch &&
 492       old_sigwinch != (SigHandler *)SIG_IGN &&
 493       old_sigwinch != (SigHandler *)SIG_DFL)
 494     (*old_sigwinch) (sig);
 495 #if !defined (VOID_SIGHANDLER)
 496   return (0);
 497 #endif /* VOID_SIGHANDLER */
 498 }
 499 #endif  /* SIGWINCH */
 500
 501 #if defined (HANDLE_SIGNALS)
 502 /* Interrupt handling. */
 503 static SigHandler
 504   *old_int  = (SigHandler *)NULL,
 505   *old_tstp = (SigHandler *)NULL,
 506   *old_ttou = (SigHandler *)NULL,
 507   *old_ttin = (SigHandler *)NULL,
 508   *old_cont = (SigHandler *)NULL,
 509   *old_alrm = (SigHandler *)NULL;
 510
 511 /* Handle an interrupt character. */
 512 static sighandler
 513 rl_signal_handler (sig)
 514      int sig;
 515 {
 516 #if !defined (HAVE_BSD_SIGNALS)
 517   /* Since the signal will not be blocked while we are in the signal
 518      handler, ignore it until rl_clear_signals resets the catcher. */
 519   if (sig == SIGINT)
 520     signal (sig, SIG_IGN);
 521 #endif /* !HAVE_BSD_SIGNALS */
 522
 523   switch (sig)
 524     {
 525     case SIGINT:
 526       free_undo_list ();
 527       rl_clear_message ();
 528       rl_init_argument ();
 529
 530 #if defined (SIGTSTP)
 531     case SIGTSTP:
 532     case SIGTTOU:
 533     case SIGTTIN:
 534 #endif /* SIGTSTP */
 535     case SIGALRM:
 536       rl_clean_up_for_exit ();
 537       rl_deprep_terminal ();
 538       rl_clear_signals ();
 539       rl_pending_input = 0;
 540
 541       kill (getpid (), sig);
 542
 543 #if defined (HAVE_POSIX_SIGNALS)
 544       {
 545         sigset_t set;
 546
 547         sigemptyset (&set);
 548         sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
 549       }
 550 #else
 551 #if defined (HAVE_BSD_SIGNALS)
 552       sigsetmask (0);
 553 #endif /* HAVE_BSD_SIGNALS */
 554 #endif /* HAVE_POSIX_SIGNALS */
 555
 556       rl_prep_terminal ();
 557       rl_set_signals ();
 558     }
 559
 560 #if !defined (VOID_SIGHANDLER)
 561   return (0);
 562 #endif /* !VOID_SIGHANDLER */
 563 }
 564
 565 rl_set_signals ()
 566 {
 567   old_int = (SigHandler *)signal (SIGINT, rl_signal_handler);
 568   if (old_int == (SigHandler *)SIG_IGN)
 569     signal (SIGINT, SIG_IGN);
 570
 571   old_alrm = (SigHandler *)signal (SIGALRM, rl_signal_handler);
 572   if (old_alrm == (SigHandler *)SIG_IGN)
 573     signal (SIGALRM, SIG_IGN);
 574
 575 #if defined (SIGTSTP)
 576   old_tstp = (SigHandler *)signal (SIGTSTP, rl_signal_handler);
 577   if (old_tstp == (SigHandler *)SIG_IGN)
 578     signal (SIGTSTP, SIG_IGN);
 579 #endif
 580 #if defined (SIGTTOU)
 581   old_ttou = (SigHandler *)signal (SIGTTOU, rl_signal_handler);
 582   old_ttin = (SigHandler *)signal (SIGTTIN, rl_signal_handler);
 583
 584   if (old_tstp == (SigHandler *)SIG_IGN)
 585     {
 586       signal (SIGTTOU, SIG_IGN);
 587       signal (SIGTTIN, SIG_IGN);
 588     }
 589 #endif
 590
 591 #if defined (SIGWINCH)
 592   old_sigwinch = (SigHandler *)signal (SIGWINCH, rl_handle_sigwinch);
 593 #endif
 594 }
 595
 596 rl_clear_signals ()
 597 {
 598   signal (SIGINT, old_int);
 599   signal (SIGALRM, old_alrm);
 600
 601 #if defined (SIGTSTP)
 602   signal (SIGTSTP, old_tstp);
 603 #endif
 604
 605 #if defined (SIGTTOU)
 606   signal (SIGTTOU, old_ttou);
 607   signal (SIGTTIN, old_ttin);
 608 #endif
 609
 610 #if defined (SIGWINCH)
 611       signal (SIGWINCH, old_sigwinch);
 612 #endif
 613 }
 614 #endif  /* HANDLE_SIGNALS */
 615
 616 \f
 617 /* **************************************************************** */
 618 /*                                                                  */
 619 /*                      Character Input Buffering                   */
 620 /*                                                                  */
 621 /* **************************************************************** */
 622
 623 #if defined (USE_XON_XOFF)
 624 /* If the terminal was in xoff state when we got to it, then xon_char
 625    contains the character that is supposed to start it again. */
 626 static int xon_char, xoff_state;
 627 #endif /* USE_XON_XOFF */
 628
 629 static int pop_index = 0, push_index = 0, ibuffer_len = 511;
 630 static unsigned char ibuffer[512];
 631
 632 /* Non-null means it is a pointer to a function to run while waiting for
 633    character input. */
 634 Function *rl_event_hook = (Function *)NULL;
 635
 636 #define any_typein (push_index != pop_index)
 637
 638 /* Add KEY to the buffer of characters to be read. */
 639 rl_stuff_char (key)
 640      int key;
 641 {
 642   if (key == EOF)
 643     {
 644       key = NEWLINE;
 645       rl_pending_input = EOF;
 646     }
 647   ibuffer[push_index++] = key;
 648   if (push_index >= ibuffer_len)
 649     push_index = 0;
 650 }
 651
 652 /* Return the amount of space available in the
 653    buffer for stuffing characters. */
 654 int
 655 ibuffer_space ()
 656 {
 657   if (pop_index > push_index)
 658     return (pop_index - push_index);
 659   else
 660     return (ibuffer_len - (push_index - pop_index));
 661 }
 662
 663 /* Get a key from the buffer of characters to be read.
 664    Return the key in KEY.
 665    Result is KEY if there was a key, or 0 if there wasn't. */
 666 int
 667 rl_get_char (key)
 668      int *key;
 669 {
 670   if (push_index == pop_index)
 671     return (0);
 672
 673   *key = ibuffer[pop_index++];
 674
 675   if (pop_index >= ibuffer_len)
 676     pop_index = 0;
 677
 678   return (1);
 679 }
 680
 681 /* Stuff KEY into the *front* of the input buffer.
 682    Returns non-zero if successful, zero if there is
 683    no space left in the buffer. */
 684 int
 685 rl_unget_char (key)
 686      int key;
 687 {
 688   if (ibuffer_space ())
 689     {
 690       pop_index--;
 691       if (pop_index < 0)
 692         pop_index = ibuffer_len - 1;
 693       ibuffer[pop_index] = key;
 694       return (1);
 695     }
 696   return (0);
 697 }
 698
 699 /* If a character is available to be read, then read it
 700    and stuff it into IBUFFER.  Otherwise, just return. */
 701 rl_gather_tyi ()
 702 {
 703 #ifdef __GO32__
 704   char input;
 705   if (isatty(0))
 706   {
 707     int i = rl_getc();
 708     if (i != EOF)
 709       rl_stuff_char(i);
 710   }
 711   else
 712     if (kbhit() && ibuffer_space())
 713       rl_stuff_char(getkey());
 714 #else
 715   int tty = fileno (in_stream);
 716   register int tem, result = -1;
 717   long chars_avail;
 718   char input;
 719
 720 #if defined (FIONREAD)
 721   result = ioctl (tty, FIONREAD, &chars_avail);
 722 #endif
 723
 724   if (result == -1)
 725     {
 726       int flags;
 727
 728       flags = fcntl (tty, F_GETFL, 0);
 729
 730       fcntl (tty, F_SETFL, (flags | O_NDELAY));
 731       chars_avail = read (tty, &input, 1);
 732
 733       fcntl (tty, F_SETFL, flags);
 734       if (chars_avail == -1 && errno == EAGAIN)
 735         return;
 736     }
 737
 738   /* If there's nothing available, don't waste time trying to read
 739      something. */
 740   if (chars_avail == 0)
 741     return;
 742
 743   tem = ibuffer_space ();
 744
 745   if (chars_avail > tem)
 746     chars_avail = tem;
 747
 748   /* One cannot read all of the available input.  I can only read a single
 749      character at a time, or else programs which require input can be
 750      thwarted.  If the buffer is larger than one character, I lose.
 751      Damn! */
 752   if (tem < ibuffer_len)
 753     chars_avail = 0;
 754
 755   if (result != -1)
 756     {
 757       while (chars_avail--)
 758         rl_stuff_char (rl_getc (in_stream));
 759     }
 760   else
 761     {
 762       if (chars_avail)
 763         rl_stuff_char (input);
 764     }
 765 #endif /* def __GO32__/else */
 766 }
 767
 768 static int next_macro_key ();
 769 /* Read a key, including pending input. */
 770 int
 771 rl_read_key ()
 772 {
 773   int c;
 774
 775   rl_key_sequence_length++;
 776
 777   if (rl_pending_input)
 778     {
 779       c = rl_pending_input;
 780       rl_pending_input = 0;
 781     }
 782   else
 783     {
 784       /* If input is coming from a macro, then use that. */
 785       if (c = next_macro_key ())
 786         return (c);
 787
 788       /* If the user has an event function, then call it periodically. */
 789       if (rl_event_hook)
 790         {
 791           while (rl_event_hook && !rl_get_char (&c))
 792             {
 793               (*rl_event_hook) ();
 794               rl_gather_tyi ();
 795             }
 796         }
 797       else
 798         {
 799           if (!rl_get_char (&c))
 800             c = rl_getc (in_stream);
 801         }
 802     }
 803
 804   return (c);
 805 }
 806
 807 /* I'm beginning to hate the declaration rules for various compilers. */
 808 static void add_macro_char (), with_macro_input ();
 809
 810 /* Do the command associated with KEY in MAP.
 811    If the associated command is really a keymap, then read
 812    another key, and dispatch into that map. */
 813 rl_dispatch (key, map)
 814      register int key;
 815      Keymap map;
 816 {
 817
 818   if (defining_kbd_macro)
 819     add_macro_char (key);
 820
 821   if (key > 127 && key < 256)
 822     {
 823       if (map[ESC].type == ISKMAP)
 824         {
 825           map = (Keymap)map[ESC].function;
 826           key -= 128;
 827           rl_dispatch (key, map);
 828         }
 829       else
 830         ding ();
 831       return;
 832     }
 833
 834   switch (map[key].type)
 835     {
 836     case ISFUNC:
 837       {
 838         Function *func = map[key].function;
 839
 840         if (func != (Function *)NULL)
 841           {
 842             /* Special case rl_do_lowercase_version (). */
 843             if (func == rl_do_lowercase_version)
 844               {
 845                 rl_dispatch (to_lower (key), map);
 846                 return;
 847               }
 848
 849             (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);
 850
 851             /* If we have input pending, then the last command was a prefix
 852                command.  Don't change the state of rl_last_func.  Otherwise,
 853                remember the last command executed in this variable. */
 854             if (!rl_pending_input)
 855               rl_last_func = map[key].function;
 856           }
 857         else
 858           {
 859             rl_abort ();
 860             return;
 861           }
 862       }
 863       break;
 864
 865     case ISKMAP:
 866       if (map[key].function != (Function *)NULL)
 867         {
 868           int newkey;
 869
 870           rl_key_sequence_length++;
 871           newkey = rl_read_key ();
 872           rl_dispatch (newkey, (Keymap)map[key].function);
 873         }
 874       else
 875         {
 876           rl_abort ();
 877           return;
 878         }
 879       break;
 880
 881     case ISMACR:
 882       if (map[key].function != (Function *)NULL)
 883         {
 884           char *macro;
 885
 886           macro = savestring ((char *)map[key].function);
 887           with_macro_input (macro);
 888           return;
 889         }
 890       break;
 891     }
 892 }
 893
 894 \f
 895 /* **************************************************************** */
 896 /*                                                                  */
 897 /*                      Hacking Keyboard Macros                     */
 898 /*                                                                  */
 899 /* **************************************************************** */
 900
 901 /* The currently executing macro string.  If this is non-zero,
 902    then it is a malloc ()'ed string where input is coming from. */
 903 static char *executing_macro = (char *)NULL;
 904
 905 /* The offset in the above string to the next character to be read. */
 906 static int executing_macro_index = 0;
 907
 908 /* The current macro string being built.  Characters get stuffed
 909    in here by add_macro_char (). */
 910 static char *current_macro = (char *)NULL;
 911
 912 /* The size of the buffer allocated to current_macro. */
 913 static int current_macro_size = 0;
 914
 915 /* The index at which characters are being added to current_macro. */
 916 static int current_macro_index = 0;
 917
 918 /* A structure used to save nested macro strings.
 919    It is a linked list of string/index for each saved macro. */
 920 struct saved_macro {
 921   struct saved_macro *next;
 922   char *string;
 923   int index;
 924 };
 925
 926 /* The list of saved macros. */
 927 struct saved_macro *macro_list = (struct saved_macro *)NULL;
 928
 929 /* Forward declarations of static functions.  Thank you C. */
 930 static void push_executing_macro (), pop_executing_macro ();
 931
 932 /* This one has to be declared earlier in the file. */
 933 /* static void add_macro_char (); */
 934
 935 /* Set up to read subsequent input from STRING.
 936    STRING is free ()'ed when we are done with it. */
 937 static void
 938 with_macro_input (string)
 939      char *string;
 940 {
 941   push_executing_macro ();
 942   executing_macro = string;
 943   executing_macro_index = 0;
 944 }
 945
 946 /* Return the next character available from a macro, or 0 if
 947    there are no macro characters. */
 948 static int
 949 next_macro_key ()
 950 {
 951   if (!executing_macro)
 952     return (0);
 953
 954   if (!executing_macro[executing_macro_index])
 955     {
 956       pop_executing_macro ();
 957       return (next_macro_key ());
 958     }
 959
 960   return (executing_macro[executing_macro_index++]);
 961 }
 962
 963 /* Save the currently executing macro on a stack of saved macros. */
 964 static void
 965 push_executing_macro ()
 966 {
 967   struct saved_macro *saver;
 968
 969   saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
 970   saver->next = macro_list;
 971   saver->index = executing_macro_index;
 972   saver->string = executing_macro;
 973
 974   macro_list = saver;
 975 }
 976
 977 /* Discard the current macro, replacing it with the one
 978    on the top of the stack of saved macros. */
 979 static void
 980 pop_executing_macro ()
 981 {
 982   if (executing_macro)
 983     free (executing_macro);
 984
 985   executing_macro = (char *)NULL;
 986   executing_macro_index = 0;
 987
 988   if (macro_list)
 989     {
 990       struct saved_macro *disposer = macro_list;
 991       executing_macro = macro_list->string;
 992       executing_macro_index = macro_list->index;
 993       macro_list = macro_list->next;
 994       free (disposer);
 995     }
 996 }
 997
 998 /* Add a character to the macro being built. */
 999 static void
1000 add_macro_char (c)
1001      int c;
1002 {
1003   if (current_macro_index + 1 >= current_macro_size)
1004     {
1005       if (!current_macro)
1006         current_macro = (char *)xmalloc (current_macro_size = 25);
1007       else
1008         current_macro =
1009           (char *)xrealloc (current_macro, current_macro_size += 25);
1010     }
1011
1012   current_macro[current_macro_index++] = c;
1013   current_macro[current_macro_index] = '\0';
1014 }
1015
1016 /* Begin defining a keyboard macro.
1017    Keystrokes are recorded as they are executed.
1018    End the definition with rl_end_kbd_macro ().
1019    If a numeric argument was explicitly typed, then append this
1020    definition to the end of the existing macro, and start by
1021    re-executing the existing macro. */
1022 rl_start_kbd_macro (ignore1, ignore2)
1023      int ignore1, ignore2;
1024 {
1025   if (defining_kbd_macro)
1026     rl_abort ();
1027
1028   if (rl_explicit_arg)
1029     {
1030       if (current_macro)
1031         with_macro_input (savestring (current_macro));
1032     }
1033   else
1034     current_macro_index = 0;
1035
1036   defining_kbd_macro = 1;
1037 }
1038
1039 /* Stop defining a keyboard macro.
1040    A numeric argument says to execute the macro right now,
1041    that many times, counting the definition as the first time. */
1042 rl_end_kbd_macro (count, ignore)
1043      int count, ignore;
1044 {
1045   if (!defining_kbd_macro)
1046     rl_abort ();
1047
1048   current_macro_index -= (rl_key_sequence_length - 1);
1049   current_macro[current_macro_index] = '\0';
1050
1051   defining_kbd_macro = 0;
1052
1053   rl_call_last_kbd_macro (--count, 0);
1054 }
1055
1056 /* Execute the most recently defined keyboard macro.
1057    COUNT says how many times to execute it. */
1058 rl_call_last_kbd_macro (count, ignore)
1059      int count, ignore;
1060 {
1061   if (!current_macro)
1062     rl_abort ();
1063
1064   while (count--)
1065     with_macro_input (savestring (current_macro));
1066 }
1067
1068 \f
1069 /* **************************************************************** */
1070 /*                                                                  */
1071 /*                      Initializations                             */
1072 /*                                                                  */
1073 /* **************************************************************** */
1074
1075 /* Initliaze readline (and terminal if not already). */
1076 rl_initialize ()
1077 {
1078   extern char *rl_display_prompt;
1079
1080   /* If we have never been called before, initialize the
1081      terminal and data structures. */
1082   if (!rl_initialized)
1083     {
1084       readline_initialize_everything ();
1085       rl_initialized++;
1086     }
1087
1088   /* Initalize the current line information. */
1089   rl_point = rl_end = 0;
1090   the_line = rl_line_buffer;
1091   the_line[0] = 0;
1092
1093   /* We aren't done yet.  We haven't even gotten started yet! */
1094   rl_done = 0;
1095
1096   /* Tell the history routines what is going on. */
1097   start_using_history ();
1098
1099   /* Make the display buffer match the state of the line. */
1100   {
1101     extern char *rl_display_prompt;
1102     extern int forced_display;
1103
1104     rl_on_new_line ();
1105
1106     rl_display_prompt = rl_prompt ? rl_prompt : "";
1107     forced_display = 1;
1108   }
1109
1110   /* No such function typed yet. */
1111   rl_last_func = (Function *)NULL;
1112
1113   /* Parsing of key-bindings begins in an enabled state. */
1114   parsing_conditionalized_out = 0;
1115 }
1116
1117 /* Initialize the entire state of the world. */
1118 readline_initialize_everything ()
1119 {
1120   /* Find out if we are running in Emacs. */
1121   running_in_emacs = getenv ("EMACS");
1122
1123   /* Set up input and output if they aren't already.  */
1124   if (!rl_instream)
1125     rl_instream = stdin;
1126   if (!rl_outstream)
1127     rl_outstream = stdout;
1128
1129   /* Allocate data structures. */
1130   if (!rl_line_buffer)
1131     rl_line_buffer =
1132       (char *)xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE);
1133
1134   /* Initialize the terminal interface. */
1135   init_terminal_io ((char *)NULL);
1136
1137   /* Bind tty characters to readline functions. */
1138   readline_default_bindings ();
1139
1140   /* Initialize the function names. */
1141   rl_initialize_funmap ();
1142
1143   /* Read in the init file. */
1144   rl_read_init_file ((char *)NULL);
1145
1146   /* If the completion parser's default word break characters haven't
1147      been set yet, then do so now. */
1148   {
1149     extern char *rl_completer_word_break_characters;
1150     extern char *rl_basic_word_break_characters;
1151
1152     if (rl_completer_word_break_characters == (char *)NULL)
1153       rl_completer_word_break_characters = rl_basic_word_break_characters;
1154   }
1155 }
1156
1157 /* If this system allows us to look at the values of the regular
1158    input editing characters, then bind them to their readline
1159    equivalents, iff the characters are not bound to keymaps. */
1160 readline_default_bindings ()
1161 {
1162 #ifndef __GO32__
1163
1164 #if defined (NEW_TTY_DRIVER)
1165   struct sgttyb ttybuff;
1166   int tty = fileno (rl_instream);
1167
1168   if (ioctl (tty, TIOCGETP, &ttybuff) != -1)
1169     {
1170       int erase, kill;
1171
1172       erase = ttybuff.sg_erase;
1173       kill  = ttybuff.sg_kill;
1174
1175       if (erase != -1 && keymap[erase].type == ISFUNC)
1176         keymap[erase].function = rl_rubout;
1177
1178       if (kill != -1 && keymap[kill].type == ISFUNC)
1179         keymap[kill].function = rl_unix_line_discard;
1180     }
1181
1182 #if defined (TIOCGLTC)
1183   {
1184     struct ltchars lt;
1185
1186     if (ioctl (tty, TIOCGLTC, &lt) != -1)
1187       {
1188         int erase, nextc;
1189
1190         erase = lt.t_werasc;
1191         nextc = lt.t_lnextc;
1192
1193         if (erase != -1 && keymap[erase].type == ISFUNC)
1194           keymap[erase].function = rl_unix_word_rubout;
1195
1196         if (nextc != -1 && keymap[nextc].type == ISFUNC)
1197           keymap[nextc].function = rl_quoted_insert;
1198       }
1199   }
1200 #endif /* TIOCGLTC */
1201 #else /* not NEW_TTY_DRIVER */
1202
1203 #if defined (TERMIOS_TTY_DRIVER)
1204   struct termios ttybuff;
1205 #else
1206   struct termio ttybuff;
1207 #endif /* TERMIOS_TTY_DRIVER */
1208   int tty = fileno (rl_instream);
1209
1210 #if defined (TERMIOS_TTY_DRIVER)
1211   if (tcgetattr (tty, &ttybuff) != -1)
1212 #else
1213   if (ioctl (tty, TCGETA, &ttybuff) != -1)
1214 #endif /* !TERMIOS_TTY_DRIVER */
1215     {
1216       int erase, kill;
1217
1218       erase = ttybuff.c_cc[VERASE];
1219       kill = ttybuff.c_cc[VKILL];
1220
1221       if (erase != _POSIX_VDISABLE &&
1222           keymap[(unsigned char)erase].type == ISFUNC)
1223         keymap[(unsigned char)erase].function = rl_rubout;
1224
1225       if (kill != _POSIX_VDISABLE &&
1226           keymap[(unsigned char)kill].type == ISFUNC)
1227         keymap[(unsigned char)kill].function = rl_unix_line_discard;
1228
1229 #if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
1230       {
1231         int nextc;
1232
1233         nextc = ttybuff.c_cc[VLNEXT];
1234
1235         if (nextc != _POSIX_VDISABLE &&
1236             keymap[(unsigned char)nextc].type == ISFUNC)
1237           keymap[(unsigned char)nextc].function = rl_quoted_insert;
1238       }
1239 #endif /* VLNEXT && TERMIOS_TTY_DRIVER */
1240
1241 #if defined (VWERASE)
1242       {
1243         int werase;
1244
1245         werase = ttybuff.c_cc[VWERASE];
1246
1247         if (werase != _POSIX_VDISABLE &&
1248             keymap[(unsigned char)werase].type == ISFUNC)
1249           keymap[(unsigned char)werase].function = rl_unix_word_rubout;
1250       }
1251 #endif /* VWERASE */
1252     }
1253 #endif /* !NEW_TTY_DRIVER */
1254 #endif /* def __GO32__ */
1255 }
1256
1257 \f
1258 /* **************************************************************** */
1259 /*                                                                  */
1260 /*                      Numeric Arguments                           */
1261 /*                                                                  */
1262 /* **************************************************************** */
1263
1264 /* Handle C-u style numeric args, as well as M--, and M-digits. */
1265
1266 /* Add the current digit to the argument in progress. */
1267 rl_digit_argument (ignore, key)
1268      int ignore, key;
1269 {
1270   rl_pending_input = key;
1271   rl_digit_loop ();
1272 }
1273
1274 /* What to do when you abort reading an argument. */
1275 rl_discard_argument ()
1276 {
1277   ding ();
1278   rl_clear_message ();
1279   rl_init_argument ();
1280 }
1281
1282 /* Create a default argument. */
1283 rl_init_argument ()
1284 {
1285   rl_numeric_arg = rl_arg_sign = 1;
1286   rl_explicit_arg = 0;
1287 }
1288
1289 /* C-u, universal argument.  Multiply the current argument by 4.
1290    Read a key.  If the key has nothing to do with arguments, then
1291    dispatch on it.  If the key is the abort character then abort. */
1292 rl_universal_argument ()
1293 {
1294   rl_numeric_arg *= 4;
1295   rl_digit_loop ();
1296 }
1297
1298 rl_digit_loop ()
1299 {
1300   int key, c;
1301   while (1)
1302     {
1303       rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg);
1304       key = c = rl_read_key ();
1305
1306       if (keymap[c].type == ISFUNC &&
1307           keymap[c].function == rl_universal_argument)
1308         {
1309           rl_numeric_arg *= 4;
1310           continue;
1311         }
1312       c = UNMETA (c);
1313       if (numeric (c))
1314         {
1315           if (rl_explicit_arg)
1316             rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0');
1317           else
1318             rl_numeric_arg = (c - '0');
1319           rl_explicit_arg = 1;
1320         }
1321       else
1322         {
1323           if (c == '-' && !rl_explicit_arg)
1324             {
1325               rl_numeric_arg = 1;
1326               rl_arg_sign = -1;
1327             }
1328           else
1329             {
1330               rl_clear_message ();
1331               rl_dispatch (key, keymap);
1332               return;
1333             }
1334         }
1335     }
1336 }
1337
1338 \f
1339 /* **************************************************************** */
1340 /*                                                                  */
1341 /*                      Display stuff                               */
1342 /*                                                                  */
1343 /* **************************************************************** */
1344
1345 /* This is the stuff that is hard for me.  I never seem to write good
1346    display routines in C.  Let's see how I do this time. */
1347
1348 /* (PWP) Well... Good for a simple line updater, but totally ignores
1349    the problems of input lines longer than the screen width.
1350
1351    update_line and the code that calls it makes a multiple line,
1352    automatically wrapping line update.  Carefull attention needs
1353    to be paid to the vertical position variables.
1354
1355    handling of terminals with autowrap on (incl. DEC braindamage)
1356    could be improved a bit.  Right now I just cheat and decrement
1357    screenwidth by one. */
1358
1359 /* Keep two buffers; one which reflects the current contents of the
1360    screen, and the other to draw what we think the new contents should
1361    be.  Then compare the buffers, and make whatever changes to the
1362    screen itself that we should.  Finally, make the buffer that we
1363    just drew into be the one which reflects the current contents of the
1364    screen, and place the cursor where it belongs.
1365
1366    Commands that want to can fix the display themselves, and then let
1367    this function know that the display has been fixed by setting the
1368    RL_DISPLAY_FIXED variable.  This is good for efficiency. */
1369
1370 /* Termcap variables: */
1371 extern char *term_up, *term_dc, *term_cr;
1372 extern int screenheight, screenwidth, terminal_can_insert;
1373
1374 /* What YOU turn on when you have handled all redisplay yourself. */
1375 int rl_display_fixed = 0;
1376
1377 /* The visible cursor position.  If you print some text, adjust this. */
1378 int last_c_pos = 0;
1379 int last_v_pos = 0;
1380
1381 /* The last left edge of text that was displayed.  This is used when
1382    doing horizontal scrolling.  It shifts in thirds of a screenwidth. */
1383 static int last_lmargin = 0;
1384
1385 /* The line display buffers.  One is the line currently displayed on
1386    the screen.  The other is the line about to be displayed. */
1387 static char *visible_line = (char *)NULL;
1388 static char *invisible_line = (char *)NULL;
1389
1390 /* Number of lines currently on screen minus 1. */
1391 int vis_botlin = 0;
1392
1393 /* A buffer for `modeline' messages. */
1394 char msg_buf[128];
1395
1396 /* Non-zero forces the redisplay even if we thought it was unnecessary. */
1397 int forced_display = 0;
1398
1399 /* The stuff that gets printed out before the actual text of the line.
1400    This is usually pointing to rl_prompt. */
1401 char *rl_display_prompt = (char *)NULL;
1402
1403 /* Default and initial buffer size.  Can grow. */
1404 static int line_size = 1024;
1405
1406 /* Non-zero means to always use horizontal scrolling in line display. */
1407 static int horizontal_scroll_mode = 0;
1408
1409 /* Non-zero means to display an asterisk at the starts of history lines
1410    which have been modified. */
1411 static int mark_modified_lines = 0;
1412
1413 /* Non-zero means to use a visible bell if one is available rather than
1414    simply ringing the terminal bell. */
1415 static int prefer_visible_bell = 0;
1416
1417 /* I really disagree with this, but my boss (among others) insists that we
1418    support compilers that don't work.  I don't think we are gaining by doing
1419    so; what is the advantage in producing better code if we can't use it? */
1420 /* The following two declarations belong inside the
1421    function block, not here. */
1422 static void move_cursor_relative ();
1423 static void output_some_chars ();
1424 static void output_character_function ();
1425 static int compare_strings ();
1426
1427 /* Basic redisplay algorithm. */
1428 rl_redisplay ()
1429 {
1430   register int in, out, c, linenum;
1431   register char *line = invisible_line;
1432   char *prompt_this_line;
1433   int c_pos = 0;
1434   int inv_botlin = 0;           /* Number of lines in newly drawn buffer. */
1435
1436   extern int readline_echoing_p;
1437
1438   if (!readline_echoing_p)
1439     return;
1440
1441   if (!rl_display_prompt)
1442     rl_display_prompt = "";
1443
1444   if (!invisible_line)
1445     {
1446       visible_line = (char *)xmalloc (line_size);
1447       invisible_line = (char *)xmalloc (line_size);
1448       line = invisible_line;
1449       for (in = 0; in < line_size; in++)
1450         {
1451           visible_line[in] = 0;
1452           invisible_line[in] = 1;
1453         }
1454       rl_on_new_line ();
1455     }
1456
1457   /* Draw the line into the buffer. */
1458   c_pos = -1;
1459
1460   /* Mark the line as modified or not.  We only do this for history
1461      lines. */
1462   out = 0;
1463   if (mark_modified_lines && current_history () && rl_undo_list)
1464     {
1465       line[out++] = '*';
1466       line[out] = '\0';
1467     }
1468
1469   /* If someone thought that the redisplay was handled, but the currently
1470      visible line has a different modification state than the one about
1471      to become visible, then correct the callers misconception. */
1472   if (visible_line[0] != invisible_line[0])
1473     rl_display_fixed = 0;
1474
1475   prompt_this_line = rindex (rl_display_prompt, '\n');
1476   if (!prompt_this_line)
1477     prompt_this_line = rl_display_prompt;
1478   else
1479     {
1480       prompt_this_line++;
1481       if (forced_display)
1482         output_some_chars (rl_display_prompt,
1483                            prompt_this_line - rl_display_prompt);
1484     }
1485
1486   strncpy (line + out,  prompt_this_line, strlen (prompt_this_line));
1487   out += strlen (prompt_this_line);
1488   line[out] = '\0';
1489
1490   for (in = 0; in < rl_end; in++)
1491     {
1492       c = (unsigned char)the_line[in];
1493
1494       if (out + 1 >= line_size)
1495         {
1496           line_size *= 2;
1497           visible_line = (char *)xrealloc (visible_line, line_size);
1498           invisible_line = (char *)xrealloc (invisible_line, line_size);
1499           line = invisible_line;
1500         }
1501
1502       if (in == rl_point)
1503         c_pos = out;
1504
1505       if (c > 127)
1506         {
1507           line[out++] = 'M';
1508           line[out++] = '-';
1509           line[out++] = c - 128;
1510         }
1511 #define DISPLAY_TABS
1512 #if defined (DISPLAY_TABS)
1513       else if (c == '\t')
1514         {
1515           register int newout = (out | (int)7) + 1;
1516           while (out < newout)
1517             line[out++] = ' ';
1518         }
1519 #endif
1520       else if (c < 32)
1521         {
1522           line[out++] = 'C';
1523           line[out++] = '-';
1524           line[out++] = c + 64;
1525         }
1526       else if (c == 127)
1527         {
1528           line[out++] = 'C';
1529           line[out++] = '-';
1530           line[out++] = '?';
1531         }
1532       else
1533         line[out++] = c;
1534     }
1535   line[out] = '\0';
1536   if (c_pos < 0)
1537     c_pos = out;
1538
1539   /* PWP: now is when things get a bit hairy.  The visible and invisible
1540      line buffers are really multiple lines, which would wrap every
1541      (screenwidth - 1) characters.  Go through each in turn, finding
1542      the changed region and updating it.  The line order is top to bottom. */
1543
1544   /* If we can move the cursor up and down, then use multiple lines,
1545      otherwise, let long lines display in a single terminal line, and
1546      horizontally scroll it. */
1547
1548   if (!horizontal_scroll_mode && term_up && *term_up)
1549     {
1550       int total_screen_chars = (screenwidth * screenheight);
1551
1552       if (!rl_display_fixed || forced_display)
1553         {
1554           forced_display = 0;
1555
1556           /* If we have more than a screenful of material to display, then
1557              only display a screenful.  We should display the last screen,
1558              not the first.  I'll fix this in a minute. */
1559           if (out >= total_screen_chars)
1560             out = total_screen_chars - 1;
1561
1562           /* Number of screen lines to display. */
1563           inv_botlin = out / screenwidth;
1564
1565           /* For each line in the buffer, do the updating display. */
1566           for (linenum = 0; linenum <= inv_botlin; linenum++)
1567             update_line (linenum > vis_botlin ? ""
1568                          : &visible_line[linenum * screenwidth],
1569                          &invisible_line[linenum * screenwidth],
1570                          linenum);
1571
1572           /* We may have deleted some lines.  If so, clear the left over
1573              blank ones at the bottom out. */
1574           if (vis_botlin > inv_botlin)
1575             {
1576               char *tt;
1577               for (; linenum <= vis_botlin; linenum++)
1578                 {
1579                   tt = &visible_line[linenum * screenwidth];
1580                   move_vert (linenum);
1581                   move_cursor_relative (0, tt);
1582                   clear_to_eol ((linenum == vis_botlin)?
1583                                 strlen (tt) : screenwidth);
1584                 }
1585             }
1586           vis_botlin = inv_botlin;
1587
1588           /* Move the cursor where it should be. */
1589           move_vert (c_pos / screenwidth);
1590           move_cursor_relative (c_pos % screenwidth,
1591                                 &invisible_line[(c_pos / screenwidth) * screenwidth]);
1592         }
1593     }
1594   else                          /* Do horizontal scrolling. */
1595     {
1596       int lmargin;
1597
1598       /* Always at top line. */
1599       last_v_pos = 0;
1600
1601       /* If the display position of the cursor would be off the edge
1602          of the screen, start the display of this line at an offset that
1603          leaves the cursor on the screen. */
1604       if (c_pos - last_lmargin > screenwidth - 2)
1605         lmargin = (c_pos / (screenwidth / 3) - 2) * (screenwidth / 3);
1606       else if (c_pos - last_lmargin < 1)
1607         lmargin = ((c_pos - 1) / (screenwidth / 3)) * (screenwidth / 3);
1608       else
1609         lmargin = last_lmargin;
1610
1611       /* If the first character on the screen isn't the first character
1612          in the display line, indicate this with a special character. */
1613       if (lmargin > 0)
1614         line[lmargin] = '<';
1615
1616       if (lmargin + screenwidth < out)
1617         line[lmargin + screenwidth - 1] = '>';
1618
1619       if (!rl_display_fixed || forced_display || lmargin != last_lmargin)
1620         {
1621           forced_display = 0;
1622           update_line (&visible_line[last_lmargin],
1623                        &invisible_line[lmargin], 0);
1624
1625           move_cursor_relative (c_pos - lmargin, &invisible_line[lmargin]);
1626           last_lmargin = lmargin;
1627         }
1628     }
1629   fflush (out_stream);
1630
1631   /* Swap visible and non-visible lines. */
1632   {
1633     char *temp = visible_line;
1634     visible_line = invisible_line;
1635     invisible_line = temp;
1636     rl_display_fixed = 0;
1637   }
1638 }
1639
1640 /* PWP: update_line() is based on finding the middle difference of each
1641    line on the screen; vis:
1642
1643                              /old first difference
1644         /beginning of line   |              /old last same       /old EOL
1645         v                    v              v                    v
1646 old:    eddie> Oh, my little gruntle-buggy is to me, as lurgid as
1647 new:    eddie> Oh, my little buggy says to me, as lurgid as
1648         ^                    ^        ^                    ^
1649         \beginning of line   |        \new last same       \new end of line
1650                              \new first difference
1651
1652    All are character pointers for the sake of speed.  Special cases for
1653    no differences, as well as for end of line additions must be handeled.
1654
1655    Could be made even smarter, but this works well enough */
1656 static
1657 update_line (old, new, current_line)
1658      register char *old, *new;
1659      int current_line;
1660 {
1661   register char *ofd, *ols, *oe, *nfd, *nls, *ne;
1662   int lendiff, wsatend;
1663
1664   /* Find first difference. */
1665   for (ofd = old, nfd = new;
1666        (ofd - old < screenwidth) && *ofd && (*ofd == *nfd);
1667        ofd++, nfd++)
1668     ;
1669
1670   /* Move to the end of the screen line. */
1671   for (oe = ofd; ((oe - old) < screenwidth) && *oe; oe++);
1672   for (ne = nfd; ((ne - new) < screenwidth) && *ne; ne++);
1673
1674   /* If no difference, continue to next line. */
1675   if (ofd == oe && nfd == ne)
1676     return;
1677
1678   wsatend = 1;                  /* flag for trailing whitespace */
1679   ols = oe - 1;                 /* find last same */
1680   nls = ne - 1;
1681   while ((*ols == *nls) && (ols > ofd) && (nls > nfd))
1682     {
1683       if (*ols != ' ')
1684         wsatend = 0;
1685       ols--;
1686       nls--;
1687     }
1688
1689   if (wsatend)
1690     {
1691       ols = oe;
1692       nls = ne;
1693     }
1694   else if (*ols != *nls)
1695     {
1696       if (*ols)                 /* don't step past the NUL */
1697         ols++;
1698       if (*nls)
1699         nls++;
1700     }
1701
1702   move_vert (current_line);
1703   move_cursor_relative (ofd - old, old);
1704
1705   /* if (len (new) > len (old)) */
1706   lendiff = (nls - nfd) - (ols - ofd);
1707
1708   /* Insert (diff(len(old),len(new)) ch */
1709   if (lendiff > 0)
1710     {
1711       if (terminal_can_insert)
1712         {
1713           extern char *term_IC;
1714
1715           /* Sometimes it is cheaper to print the characters rather than
1716              use the terminal's capabilities. */
1717           if ((2 * (ne - nfd)) < lendiff && !term_IC)
1718             {
1719               output_some_chars (nfd, (ne - nfd));
1720               last_c_pos += (ne - nfd);
1721             }
1722           else
1723             {
1724               if (*ols)
1725                 {
1726                   insert_some_chars (nfd, lendiff);
1727                   last_c_pos += lendiff;
1728                 }
1729               else
1730                 {
1731                   /* At the end of a line the characters do not have to
1732                      be "inserted".  They can just be placed on the screen. */
1733                   output_some_chars (nfd, lendiff);
1734                   last_c_pos += lendiff;
1735                 }
1736               /* Copy (new) chars to screen from first diff to last match. */
1737               if (((nls - nfd) - lendiff) > 0)
1738                 {
1739                   output_some_chars (&nfd[lendiff], ((nls - nfd) - lendiff));
1740                   last_c_pos += ((nls - nfd) - lendiff);
1741                 }
1742             }
1743         }
1744       else
1745         {               /* cannot insert chars, write to EOL */
1746           output_some_chars (nfd, (ne - nfd));
1747           last_c_pos += (ne - nfd);
1748         }
1749     }
1750   else                          /* Delete characters from line. */
1751     {
1752       /* If possible and inexpensive to use terminal deletion, then do so. */
1753       if (term_dc && (2 * (ne - nfd)) >= (-lendiff))
1754         {
1755           if (lendiff)
1756             delete_chars (-lendiff); /* delete (diff) characters */
1757
1758           /* Copy (new) chars to screen from first diff to last match */
1759           if ((nls - nfd) > 0)
1760             {
1761               output_some_chars (nfd, (nls - nfd));
1762               last_c_pos += (nls - nfd);
1763             }
1764         }
1765       /* Otherwise, print over the existing material. */
1766       else
1767         {
1768           output_some_chars (nfd, (ne - nfd));
1769           last_c_pos += (ne - nfd);
1770           clear_to_eol ((oe - old) - (ne - new));
1771         }
1772     }
1773 }
1774
1775 /* (PWP) tell the update routines that we have moved onto a
1776    new (empty) line. */
1777 rl_on_new_line ()
1778 {
1779   if (visible_line)
1780     visible_line[0] = '\0';
1781
1782   last_c_pos = last_v_pos = 0;
1783   vis_botlin = last_lmargin = 0;
1784 }
1785
1786 /* Actually update the display, period. */
1787 rl_forced_update_display ()
1788 {
1789   if (visible_line)
1790     {
1791       register char *temp = visible_line;
1792
1793       while (*temp) *temp++ = '\0';
1794     }
1795   rl_on_new_line ();
1796   forced_display++;
1797   rl_redisplay ();
1798 }
1799
1800 /* Move the cursor from last_c_pos to NEW, which are buffer indices.
1801    DATA is the contents of the screen line of interest; i.e., where
1802    the movement is being done. */
1803 static void
1804 move_cursor_relative (new, data)
1805      int new;
1806      char *data;
1807 {
1808   register int i;
1809
1810   /* It may be faster to output a CR, and then move forwards instead
1811      of moving backwards. */
1812   if (new + 1 < last_c_pos - new)
1813     {
1814 #ifdef __MSDOS__
1815       putc('\r', out_stream);
1816 #else
1817       tputs (term_cr, 1, output_character_function);
1818 #endif
1819       last_c_pos = 0;
1820     }
1821
1822   if (last_c_pos == new) return;
1823
1824   if (last_c_pos < new)
1825     {
1826       /* Move the cursor forward.  We do it by printing the command
1827          to move the cursor forward if there is one, else print that
1828          portion of the output buffer again.  Which is cheaper? */
1829
1830       /* The above comment is left here for posterity.  It is faster
1831          to print one character (non-control) than to print a control
1832          sequence telling the terminal to move forward one character.
1833          That kind of control is for people who don't know what the
1834          data is underneath the cursor. */
1835 #if defined (HACK_TERMCAP_MOTION)
1836       extern char *term_forward_char;
1837
1838       if (term_forward_char)
1839         for (i = last_c_pos; i < new; i++)
1840           tputs (term_forward_char, 1, output_character_function);
1841       else
1842         for (i = last_c_pos; i < new; i++)
1843           putc (data[i], out_stream);
1844 #else
1845       for (i = last_c_pos; i < new; i++)
1846         putc (data[i], out_stream);
1847 #endif                          /* HACK_TERMCAP_MOTION */
1848     }
1849   else
1850     backspace (last_c_pos - new);
1851   last_c_pos = new;
1852 }
1853
1854 /* PWP: move the cursor up or down. */
1855 move_vert (to)
1856      int to;
1857 {
1858   void output_character_function ();
1859   register int delta, i;
1860
1861   if (last_v_pos == to) return;
1862
1863   if (to > screenheight)
1864     return;
1865
1866 #ifdef __GO32__
1867   {
1868     int cur_r, cur_c;
1869     ScreenGetCursor(&cur_r, &cur_c);
1870     ScreenSetCursor(cur_r+to-last_v_pos, cur_c);
1871   }
1872 #else /* __GO32__ */
1873   if ((delta = to - last_v_pos) > 0)
1874     {
1875       for (i = 0; i < delta; i++)
1876         putc ('\n', out_stream);
1877       tputs (term_cr, 1, output_character_function);
1878       last_c_pos = 0;
1879     }
1880   else
1881     {                   /* delta < 0 */
1882       if (term_up && *term_up)
1883         for (i = 0; i < -delta; i++)
1884           tputs (term_up, 1, output_character_function);
1885     }
1886 #endif /* __GO32__ */
1887   last_v_pos = to;              /* now to is here */
1888 }
1889
1890 /* Physically print C on out_stream.  This is for functions which know
1891    how to optimize the display. */
1892 rl_show_char (c)
1893      int c;
1894 {
1895   if (c > 127)
1896     {
1897       fprintf (out_stream, "M-");
1898       c -= 128;
1899     }
1900
1901 #if defined (DISPLAY_TABS)
1902   if (c < 32 && c != '\t')
1903 #else
1904   if (c < 32)
1905 #endif
1906     {
1907
1908       c += 64;
1909     }
1910
1911   putc (c, out_stream);
1912   fflush (out_stream);
1913 }
1914
1915 #if defined (DISPLAY_TABS)
1916 int
1917 rl_character_len (c, pos)
1918      register int c, pos;
1919 {
1920   if (c < ' ' || c > 126)
1921     {
1922       if (c == '\t')
1923         return (((pos | (int)7) + 1) - pos);
1924       else
1925         return (3);
1926     }
1927   else
1928     return (1);
1929 }
1930 #else
1931 int
1932 rl_character_len (c)
1933      int c;
1934 {
1935   if (c < ' ' || c > 126)
1936     return (3);
1937   else
1938     return (1);
1939 }
1940 #endif  /* DISPLAY_TAB */
1941
1942 /* How to print things in the "echo-area".  The prompt is treated as a
1943    mini-modeline. */
1944 rl_message (string, arg1, arg2)
1945      char *string;
1946 {
1947   sprintf (msg_buf, string, arg1, arg2);
1948   rl_display_prompt = msg_buf;
1949   rl_redisplay ();
1950 }
1951
1952 /* How to clear things from the "echo-area". */
1953 rl_clear_message ()
1954 {
1955   rl_display_prompt = rl_prompt;
1956   rl_redisplay ();
1957 }
1958 \f
1959 /* **************************************************************** */
1960 /*                                                                  */
1961 /*                      Terminal and Termcap                        */
1962 /*                                                                  */
1963 /* **************************************************************** */
1964
1965 static char *term_buffer = (char *)NULL;
1966 static char *term_string_buffer = (char *)NULL;
1967
1968 /* Non-zero means this terminal can't really do anything. */
1969 int dumb_term = 0;
1970
1971 char PC;
1972 char *BC, *UP;
1973
1974 /* Some strings to control terminal actions.  These are output by tputs (). */
1975 char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace;
1976
1977 int screenwidth, screenheight;
1978
1979 /* Non-zero if we determine that the terminal can do character insertion. */
1980 int terminal_can_insert = 0;
1981
1982 /* How to insert characters. */
1983 char *term_im, *term_ei, *term_ic, *term_ip, *term_IC;
1984
1985 /* How to delete characters. */
1986 char *term_dc, *term_DC;
1987
1988 #if defined (HACK_TERMCAP_MOTION)
1989 char *term_forward_char;
1990 #endif  /* HACK_TERMCAP_MOTION */
1991
1992 /* How to go up a line. */
1993 char *term_up;
1994
1995 /* A visible bell, if the terminal can be made to flash the screen. */
1996 char *visible_bell;
1997
1998 /* Re-initialize the terminal considering that the TERM/TERMCAP variable
1999    has changed. */
2000 rl_reset_terminal (terminal_name)
2001      char *terminal_name;
2002 {
2003   init_terminal_io (terminal_name);
2004 }
2005
2006 init_terminal_io (terminal_name)
2007      char *terminal_name;
2008 {
2009 #ifdef __GO32__
2010   screenwidth = ScreenCols();
2011   screenheight = ScreenRows();
2012   term_cr = "\r";
2013   term_im = term_ei = term_ic = term_IC = (char *)NULL;
2014   term_up = term_dc = term_DC = visible_bell = (char *)NULL;
2015 #if defined (HACK_TERMCAP_MOTION)
2016       term_forward_char = (char *)NULL;
2017 #endif
2018   terminal_can_insert = 0;
2019   return;
2020 #else
2021   extern char *tgetstr ();
2022   char *term, *buffer;
2023 #if defined (TIOCGWINSZ)
2024   struct winsize window_size;
2025 #endif
2026   int tty;
2027
2028   term = terminal_name ? terminal_name : getenv ("TERM");
2029
2030   if (!term_string_buffer)
2031     term_string_buffer = (char *)xmalloc (2048);
2032
2033   if (!term_buffer)
2034     term_buffer = (char *)xmalloc (2048);
2035
2036   buffer = term_string_buffer;
2037
2038   term_clrpag = term_cr = term_clreol = (char *)NULL;
2039
2040   if (!term)
2041     term = "dumb";
2042
2043   if (tgetent (term_buffer, term) < 0)
2044     {
2045       dumb_term = 1;
2046       screenwidth = 79;
2047       screenheight = 24;
2048       term_cr = "\r";
2049       term_im = term_ei = term_ic = term_IC = (char *)NULL;
2050       term_up = term_dc = term_DC = visible_bell = (char *)NULL;
2051 #if defined (HACK_TERMCAP_MOTION)
2052       term_forward_char = (char *)NULL;
2053 #endif
2054       terminal_can_insert = 0;
2055       return;
2056     }
2057
2058   BC = tgetstr ("pc", &buffer);
2059   PC = buffer ? *buffer : 0;
2060
2061   term_backspace = tgetstr ("le", &buffer);
2062
2063   term_cr = tgetstr ("cr", &buffer);
2064   term_clreol = tgetstr ("ce", &buffer);
2065   term_clrpag = tgetstr ("cl", &buffer);
2066
2067   if (!term_cr)
2068     term_cr =  "\r";
2069
2070 #if defined (HACK_TERMCAP_MOTION)
2071   term_forward_char = tgetstr ("nd", &buffer);
2072 #endif  /* HACK_TERMCAP_MOTION */
2073
2074   if (rl_instream)
2075     tty = fileno (rl_instream);
2076   else
2077     tty = 0;
2078
2079   screenwidth = screenheight = 0;
2080 #if defined (TIOCGWINSZ)
2081   if (ioctl (tty, TIOCGWINSZ, &window_size) == 0)
2082     {
2083       screenwidth = (int) window_size.ws_col;
2084       screenheight = (int) window_size.ws_row;
2085     }
2086 #endif
2087
2088   if (screenwidth <= 0 || screenheight <= 0)
2089     {
2090       screenwidth = tgetnum ("co");
2091       screenheight = tgetnum ("li");
2092     }
2093
2094   screenwidth--;
2095
2096   if (screenwidth <= 0)
2097     screenwidth = 79;
2098
2099   if (screenheight <= 0)
2100     screenheight = 24;
2101
2102   term_im = tgetstr ("im", &buffer);
2103   term_ei = tgetstr ("ei", &buffer);
2104   term_IC = tgetstr ("IC", &buffer);
2105   term_ic = tgetstr ("ic", &buffer);
2106
2107   /* "An application program can assume that the terminal can do
2108       character insertion if *any one of* the capabilities `IC',
2109       `im', `ic' or `ip' is provided."  But we can't do anything if
2110       only `ip' is provided, so... */
2111   terminal_can_insert = (term_IC || term_im || term_ic);
2112
2113   term_up = tgetstr ("up", &buffer);
2114   term_dc = tgetstr ("dc", &buffer);
2115   term_DC = tgetstr ("DC", &buffer);
2116
2117   visible_bell = tgetstr ("vb", &buffer);
2118 #endif /* !__GO32__ */
2119 }
2120
2121 /* A function for the use of tputs () */
2122 static void
2123 output_character_function (c)
2124      int c;
2125 {
2126   putc (c, out_stream);
2127 }
2128
2129 /* Write COUNT characters from STRING to the output stream. */
2130 static void
2131 output_some_chars (string, count)
2132      char *string;
2133      int count;
2134 {
2135   fwrite (string, 1, count, out_stream);
2136 }
2137
2138 /* Delete COUNT characters from the display line. */
2139 static
2140 delete_chars (count)
2141      int count;
2142 {
2143 #ifdef __GO32__
2144   int r, c, w;
2145   ScreenGetCursor(&r, &c);
2146   w = ScreenCols();
2147   memcpy(ScreenPrimary+r*w+c, ScreenPrimary+r*w+c+count, w-c-count);
2148   memset(ScreenPrimary+r*w+w-count, 0, count*2);
2149 #else /* __GO32__ */
2150   if (count > screenwidth)
2151     return;
2152
2153   if (term_DC && *term_DC)
2154     {
2155       char *tgoto (), *buffer;
2156       buffer = tgoto (term_DC, 0, count);
2157       tputs (buffer, 1, output_character_function);
2158     }
2159   else
2160     {
2161       if (term_dc && *term_dc)
2162         while (count--)
2163           tputs (term_dc, 1, output_character_function);
2164     }
2165 #endif /* __GO32__ */
2166 }
2167
2168 /* Insert COUNT characters from STRING to the output stream. */
2169 static
2170 insert_some_chars (string, count)
2171      char *string;
2172      int count;
2173 {
2174 #ifdef __GO32__
2175   int r, c, w;
2176   ScreenGetCursor(&r, &c);
2177   w = ScreenCols();
2178   memcpy(ScreenPrimary+r*w+c+count, ScreenPrimary+r*w+c, w-c-count);
2179   /* Print the text. */
2180   output_some_chars (string, count);
2181 #else /* __GO32__ */
2182   /* If IC is defined, then we do not have to "enter" insert mode. */
2183   if (term_IC)
2184     {
2185       char *tgoto (), *buffer;
2186       buffer = tgoto (term_IC, 0, count);
2187       tputs (buffer, 1, output_character_function);
2188       output_some_chars (string, count);
2189     }
2190   else
2191     {
2192       register int i;
2193
2194       /* If we have to turn on insert-mode, then do so. */
2195       if (term_im && *term_im)
2196         tputs (term_im, 1, output_character_function);
2197
2198       /* If there is a special command for inserting characters, then
2199          use that first to open up the space. */
2200       if (term_ic && *term_ic)
2201         {
2202           for (i = count; i--; )
2203             tputs (term_ic, 1, output_character_function);
2204         }
2205
2206       /* Print the text. */
2207       output_some_chars (string, count);
2208
2209       /* If there is a string to turn off insert mode, we had best use
2210          it now. */
2211       if (term_ei && *term_ei)
2212         tputs (term_ei, 1, output_character_function);
2213     }
2214 #endif /* __GO32__ */
2215 }
2216
2217 /* Move the cursor back. */
2218 backspace (count)
2219      int count;
2220 {
2221   register int i;
2222
2223 #ifndef __GO32__
2224   if (term_backspace)
2225     for (i = 0; i < count; i++)
2226       tputs (term_backspace, 1, output_character_function);
2227   else
2228 #endif /* !__GO32__ */
2229     for (i = 0; i < count; i++)
2230       putc ('\b', out_stream);
2231 }
2232
2233 /* Move to the start of the next line. */
2234 crlf ()
2235 {
2236 #if defined (NEW_TTY_DRIVER)
2237   tputs (term_cr, 1, output_character_function);
2238 #endif /* NEW_TTY_DRIVER */
2239   putc ('\n', out_stream);
2240 }
2241
2242 /* Clear to the end of the line.  COUNT is the minimum
2243    number of character spaces to clear, */
2244 clear_to_eol (count)
2245      int count;
2246 {
2247 #ifndef __GO32__
2248   if (term_clreol)
2249     {
2250       tputs (term_clreol, 1, output_character_function);
2251     }
2252   else
2253 #endif /* !__GO32__ */
2254     {
2255       register int i;
2256
2257       /* Do one more character space. */
2258       count++;
2259
2260       for (i = 0; i < count; i++)
2261         putc (' ', out_stream);
2262
2263       backspace (count);
2264     }
2265 }
2266
2267 \f
2268 /* **************************************************************** */
2269 /*                                                                  */
2270 /*                    Saving and Restoring the TTY                  */
2271 /*                                                                  */
2272 /* **************************************************************** */
2273
2274 /* Non-zero means that the terminal is in a prepped state. */
2275 static int terminal_prepped = 0;
2276
2277 #if defined (NEW_TTY_DRIVER)
2278
2279 /* Standard flags, including ECHO. */
2280 static int original_tty_flags = 0;
2281
2282 /* Local mode flags, like LPASS8. */
2283 static int local_mode_flags = 0;
2284
2285 /* Terminal characters.  This has C-s and C-q in it. */
2286 static struct tchars original_tchars;
2287
2288 /* Local special characters.  This has the interrupt characters in it. */
2289 #if defined (TIOCGLTC)
2290 static struct ltchars original_ltchars;
2291 #endif
2292
2293 /* We use this to get and set the tty_flags. */
2294 static struct sgttyb the_ttybuff;
2295
2296 /* Put the terminal in CBREAK mode so that we can detect key presses. */
2297 static void
2298 rl_prep_terminal ()
2299 {
2300 #ifndef __GO32__
2301   int tty = fileno (rl_instream);
2302 #if defined (HAVE_BSD_SIGNALS)
2303   int oldmask;
2304 #endif /* HAVE_BSD_SIGNALS */
2305
2306   if (terminal_prepped)
2307     return;
2308
2309   oldmask = sigblock (sigmask (SIGINT));
2310
2311   /* We always get the latest tty values.  Maybe stty changed them. */
2312   ioctl (tty, TIOCGETP, &the_ttybuff);
2313   original_tty_flags = the_ttybuff.sg_flags;
2314
2315   readline_echoing_p = (original_tty_flags & ECHO);
2316
2317 #if defined (TIOCLGET)
2318   ioctl (tty, TIOCLGET, &local_mode_flags);
2319 #endif
2320
2321 #if !defined (ANYP)
2322 #  define ANYP (EVENP | ODDP)
2323 #endif
2324
2325   /* If this terminal doesn't care how the 8th bit is used,
2326      then we can use it for the meta-key.  We check by seeing
2327      if BOTH odd and even parity are allowed. */
2328   if (the_ttybuff.sg_flags & ANYP)
2329     {
2330 #if defined (PASS8)
2331       the_ttybuff.sg_flags |= PASS8;
2332 #endif
2333
2334       /* Hack on local mode flags if we can. */
2335 #if defined (TIOCLGET) && defined (LPASS8)
2336       {
2337         int flags;
2338         flags = local_mode_flags | LPASS8;
2339         ioctl (tty, TIOCLSET, &flags);
2340       }
2341 #endif /* TIOCLGET && LPASS8 */
2342     }
2343
2344 #if defined (TIOCGETC)
2345   {
2346     struct tchars temp;
2347
2348     ioctl (tty, TIOCGETC, &original_tchars);
2349     temp = original_tchars;
2350
2351 #if defined (USE_XON_XOFF)
2352     /* Get rid of C-s and C-q.
2353        We remember the value of startc (C-q) so that if the terminal is in
2354        xoff state, the user can xon it by pressing that character. */
2355     xon_char = temp.t_startc;
2356     temp.t_stopc = -1;
2357     temp.t_startc = -1;
2358
2359     /* If there is an XON character, bind it to restart the output. */
2360     if (xon_char != -1)
2361       rl_bind_key (xon_char, rl_restart_output);
2362 #endif /* USE_XON_XOFF */
2363
2364     /* If there is an EOF char, bind eof_char to it. */
2365     if (temp.t_eofc != -1)
2366       eof_char = temp.t_eofc;
2367
2368 #if defined (NO_KILL_INTR)
2369     /* Get rid of C-\ and C-c. */
2370     temp.t_intrc = temp.t_quitc = -1;
2371 #endif /* NO_KILL_INTR */
2372
2373     ioctl (tty, TIOCSETC, &temp);
2374   }
2375 #endif /* TIOCGETC */
2376
2377 #if defined (TIOCGLTC)
2378   {
2379     struct ltchars temp;
2380
2381     ioctl (tty, TIOCGLTC, &original_ltchars);
2382     temp = original_ltchars;
2383
2384     /* Make the interrupt keys go away.  Just enough to make people
2385        happy. */
2386     temp.t_dsuspc = -1; /* C-y */
2387     temp.t_lnextc = -1; /* C-v */
2388
2389     ioctl (tty, TIOCSLTC, &temp);
2390   }
2391 #endif /* TIOCGLTC */
2392
2393   the_ttybuff.sg_flags &= ~(ECHO | CRMOD);
2394   the_ttybuff.sg_flags |= CBREAK;
2395   ioctl (tty, TIOCSETN, &the_ttybuff);
2396
2397   terminal_prepped = 1;
2398
2399 #if defined (HAVE_BSD_SIGNALS)
2400   sigsetmask (oldmask);
2401 #endif
2402 #endif /* !__GO32__ */
2403 }
2404
2405 /* Restore the terminal to its original state. */
2406 static void
2407 rl_deprep_terminal ()
2408 {
2409 #ifndef __GO32__
2410   int tty = fileno (rl_instream);
2411 #if defined (HAVE_BSD_SIGNALS)
2412   int oldmask;
2413 #endif
2414
2415   if (!terminal_prepped)
2416     return;
2417
2418   oldmask = sigblock (sigmask (SIGINT));
2419
2420   the_ttybuff.sg_flags = original_tty_flags;
2421   ioctl (tty, TIOCSETN, &the_ttybuff);
2422   readline_echoing_p = 1;
2423
2424 #if defined (TIOCLGET)
2425   ioctl (tty, TIOCLSET, &local_mode_flags);
2426 #endif
2427
2428 #if defined (TIOCSLTC)
2429   ioctl (tty, TIOCSLTC, &original_ltchars);
2430 #endif
2431
2432 #if defined (TIOCSETC)
2433   ioctl (tty, TIOCSETC, &original_tchars);
2434 #endif
2435   terminal_prepped = 0;
2436
2437 #if defined (HAVE_BSD_SIGNALS)
2438   sigsetmask (oldmask);
2439 #endif
2440 #endif /* !__GO32 */
2441 }
2442
2443 #else  /* !defined (NEW_TTY_DRIVER) */
2444
2445 #if !defined (VMIN)
2446 #define VMIN VEOF
2447 #endif
2448
2449 #if !defined (VTIME)
2450 #define VTIME VEOL
2451 #endif
2452
2453 #ifndef __GO32__
2454 #if defined (TERMIOS_TTY_DRIVER)
2455 static struct termios otio;
2456 #else
2457 static struct termio otio;
2458 #endif /* !TERMIOS_TTY_DRIVER */
2459 #endif /* __GO32__ */
2460
2461 static void
2462 rl_prep_terminal ()
2463 {
2464 #ifndef __GO32__
2465   int tty = fileno (rl_instream);
2466 #if defined (TERMIOS_TTY_DRIVER)
2467   struct termios tio;
2468 #else
2469   struct termio tio;
2470 #endif /* !TERMIOS_TTY_DRIVER */
2471
2472 #if defined (HAVE_POSIX_SIGNALS)
2473   sigset_t set, oset;
2474 #else
2475 #  if defined (HAVE_BSD_SIGNALS)
2476   int oldmask;
2477 #  endif /* HAVE_BSD_SIGNALS */
2478 #endif /* !HAVE_POSIX_SIGNALS */
2479
2480   if (terminal_prepped)
2481     return;
2482
2483   /* Try to keep this function from being INTerrupted.  We can do it
2484      on POSIX and systems with BSD-like signal handling. */
2485 #if defined (HAVE_POSIX_SIGNALS)
2486   sigemptyset (&set);
2487   sigaddset (&set, SIGINT);
2488   sigprocmask (SIG_BLOCK, &set, &oset);
2489 #else /* !HAVE_POSIX_SIGNALS */
2490 #  if defined (HAVE_BSD_SIGNALS)
2491   oldmask = sigblock (sigmask (SIGINT));
2492 #  endif /* HAVE_BSD_SIGNALS */
2493 #endif /* !HAVE_POSIX_SIGNALS */
2494
2495 #if defined (TERMIOS_TTY_DRIVER)
2496   tcgetattr (tty, &tio);
2497 #else
2498   ioctl (tty, TCGETA, &tio);
2499 #endif /* !TERMIOS_TTY_DRIVER */
2500
2501   otio = tio;
2502
2503   readline_echoing_p = (tio.c_lflag & ECHO);
2504
2505   tio.c_lflag &= ~(ICANON|ECHO);
2506
2507   if (otio.c_cc[VEOF] != _POSIX_VDISABLE)
2508     eof_char = otio.c_cc[VEOF];
2509
2510 #if defined (USE_XON_XOFF)
2511 #if defined (IXANY)
2512   tio.c_iflag &= ~(IXON|IXOFF|IXANY);
2513 #else
2514   /* `strict' Posix systems do not define IXANY. */
2515   tio.c_iflag &= ~(IXON|IXOFF);
2516 #endif /* IXANY */
2517 #endif /* USE_XON_XOFF */
2518
2519   /* Only turn this off if we are using all 8 bits. */
2520   /* |ISTRIP|INPCK */
2521   tio.c_iflag &= ~(ISTRIP | INPCK);
2522
2523   /* Make sure we differentiate between CR and NL on input. */
2524   tio.c_iflag &= ~(ICRNL | INLCR);
2525
2526 #if !defined (HANDLE_SIGNALS)
2527   tio.c_lflag &= ~ISIG;
2528 #else
2529   tio.c_lflag |= ISIG;
2530 #endif
2531
2532   tio.c_cc[VMIN] = 1;
2533   tio.c_cc[VTIME] = 0;
2534
2535   /* Turn off characters that we need on Posix systems with job control,
2536      just to be sure.  This includes ^Y and ^V.  This should not really
2537      be necessary.  */
2538 #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_JOB_CONTROL)
2539
2540 #if defined (VLNEXT)
2541   tio.c_cc[VLNEXT] = _POSIX_VDISABLE;
2542 #endif
2543
2544 #if defined (VDSUSP)
2545   tio.c_cc[VDSUSP] = _POSIX_VDISABLE;
2546 #endif
2547
2548 #endif /* POSIX && JOB_CONTROL */
2549
2550 #if defined (TERMIOS_TTY_DRIVER)
2551   tcsetattr (tty, TCSADRAIN, &tio);
2552   tcflow (tty, TCOON);          /* Simulate a ^Q. */
2553 #else
2554   ioctl (tty, TCSETAW, &tio);
2555   ioctl (tty, TCXONC, 1);       /* Simulate a ^Q. */
2556 #endif /* !TERMIOS_TTY_DRIVER */
2557
2558   terminal_prepped = 1;
2559
2560 #if defined (HAVE_POSIX_SIGNALS)
2561   sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
2562 #else
2563 #  if defined (HAVE_BSD_SIGNALS)
2564   sigsetmask (oldmask);
2565 #  endif /* HAVE_BSD_SIGNALS */
2566 #endif /* !HAVE_POSIX_SIGNALS */
2567 #endif /* !__GO32__ */
2568 }
2569
2570 static void
2571 rl_deprep_terminal ()
2572 {
2573 #ifndef __GO32__
2574   int tty = fileno (rl_instream);
2575
2576   /* Try to keep this function from being INTerrupted.  We can do it
2577      on POSIX and systems with BSD-like signal handling. */
2578 #if defined (HAVE_POSIX_SIGNALS)
2579   sigset_t set, oset;
2580 #else /* !HAVE_POSIX_SIGNALS */
2581 #  if defined (HAVE_BSD_SIGNALS)
2582   int oldmask;
2583 #  endif /* HAVE_BSD_SIGNALS */
2584 #endif /* !HAVE_POSIX_SIGNALS */
2585
2586   if (!terminal_prepped)
2587     return;
2588
2589 #if defined (HAVE_POSIX_SIGNALS)
2590   sigemptyset (&set);
2591   sigaddset (&set, SIGINT);
2592   sigprocmask (SIG_BLOCK, &set, &oset);
2593 #else /* !HAVE_POSIX_SIGNALS */
2594 #  if defined (HAVE_BSD_SIGNALS)
2595   oldmask = sigblock (sigmask (SIGINT));
2596 #  endif /* HAVE_BSD_SIGNALS */
2597 #endif /* !HAVE_POSIX_SIGNALS */
2598
2599 #if defined (TERMIOS_TTY_DRIVER)
2600   tcsetattr (tty, TCSADRAIN, &otio);
2601   tcflow (tty, TCOON);          /* Simulate a ^Q. */
2602 #else /* TERMIOS_TTY_DRIVER */
2603   ioctl (tty, TCSETAW, &otio);
2604   ioctl (tty, TCXONC, 1);       /* Simulate a ^Q. */
2605 #endif /* !TERMIOS_TTY_DRIVER */
2606
2607   terminal_prepped = 0;
2608
2609 #if defined (HAVE_POSIX_SIGNALS)
2610   sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
2611 #else /* !HAVE_POSIX_SIGNALS */
2612 #  if defined (HAVE_BSD_SIGNALS)
2613   sigsetmask (oldmask);
2614 #  endif /* HAVE_BSD_SIGNALS */
2615 #endif /* !HAVE_POSIX_SIGNALS */
2616 #endif /* !__GO32__ */
2617 }
2618 #endif  /* NEW_TTY_DRIVER */
2619
2620 \f
2621 /* **************************************************************** */
2622 /*                                                                  */
2623 /*                      Utility Functions                           */
2624 /*                                                                  */
2625 /* **************************************************************** */
2626
2627 /* Return 0 if C is not a member of the class of characters that belong
2628    in words, or 1 if it is. */
2629
2630 int allow_pathname_alphabetic_chars = 0;
2631 char *pathname_alphabetic_chars = "/-_=~.#$";
2632
2633 int
2634 alphabetic (c)
2635      int c;
2636 {
2637   if (pure_alphabetic (c) || (numeric (c)))
2638     return (1);
2639
2640   if (allow_pathname_alphabetic_chars)
2641     return ((int)rindex (pathname_alphabetic_chars, c));
2642   else
2643     return (0);
2644 }
2645
2646 /* Return non-zero if C is a numeric character. */
2647 int
2648 numeric (c)
2649      int c;
2650 {
2651   return (c >= '0' && c <= '9');
2652 }
2653
2654 /* Ring the terminal bell. */
2655 int
2656 ding ()
2657 {
2658   if (readline_echoing_p)
2659     {
2660 #ifndef __GO32__
2661       if (prefer_visible_bell && visible_bell)
2662         tputs (visible_bell, 1, output_character_function);
2663       else
2664 #endif /* !__GO32__ */
2665         {
2666           fprintf (stderr, "\007");
2667           fflush (stderr);
2668         }
2669     }
2670   return (-1);
2671 }
2672
2673 /* How to abort things. */
2674 rl_abort ()
2675 {
2676   ding ();
2677   rl_clear_message ();
2678   rl_init_argument ();
2679   rl_pending_input = 0;
2680
2681   defining_kbd_macro = 0;
2682   while (executing_macro)
2683     pop_executing_macro ();
2684
2685   rl_last_func = (Function *)NULL;
2686   longjmp (readline_top_level, 1);
2687 }
2688
2689 /* Return a copy of the string between FROM and TO.
2690    FROM is inclusive, TO is not. */
2691 #if defined (sun) /* Yes, that's right, some crufty function in sunview is
2692                      called rl_copy (). */
2693 static
2694 #endif
2695 char *
2696 rl_copy (from, to)
2697      int from, to;
2698 {
2699   register int length;
2700   char *copy;
2701
2702   /* Fix it if the caller is confused. */
2703   if (from > to)
2704     {
2705       int t = from;
2706       from = to;
2707       to = t;
2708     }
2709
2710   length = to - from;
2711   copy = (char *)xmalloc (1 + length);
2712   strncpy (copy, the_line + from, length);
2713   copy[length] = '\0';
2714   return (copy);
2715 }
2716
2717 /* Increase the size of RL_LINE_BUFFER until it has enough space to hold
2718    LEN characters. */
2719 void
2720 rl_extend_line_buffer (len)
2721      int len;
2722 {
2723   while (len >= rl_line_buffer_len)
2724     rl_line_buffer =
2725       (char *)xrealloc
2726         (rl_line_buffer, rl_line_buffer_len += DEFAULT_BUFFER_SIZE);
2727
2728   the_line = rl_line_buffer;
2729 }
2730
2731 \f
2732 /* **************************************************************** */
2733 /*                                                                  */
2734 /*                      Insert and Delete                           */
2735 /*                                                                  */
2736 /* **************************************************************** */
2737
2738 /* Insert a string of text into the line at point.  This is the only
2739    way that you should do insertion.  rl_insert () calls this
2740    function. */
2741 rl_insert_text (string)
2742      char *string;
2743 {
2744   extern int doing_an_undo;
2745   register int i, l = strlen (string);
2746
2747   if (rl_end + l >= rl_line_buffer_len)
2748     rl_extend_line_buffer (rl_end + l);
2749
2750   for (i = rl_end; i >= rl_point; i--)
2751     the_line[i + l] = the_line[i];
2752   strncpy (the_line + rl_point, string, l);
2753
2754   /* Remember how to undo this if we aren't undoing something. */
2755   if (!doing_an_undo)
2756     {
2757       /* If possible and desirable, concatenate the undos. */
2758       if ((strlen (string) == 1) &&
2759           rl_undo_list &&
2760           (rl_undo_list->what == UNDO_INSERT) &&
2761           (rl_undo_list->end == rl_point) &&
2762           (rl_undo_list->end - rl_undo_list->start < 20))
2763         rl_undo_list->end++;
2764       else
2765         rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL);
2766     }
2767   rl_point += l;
2768   rl_end += l;
2769   the_line[rl_end] = '\0';
2770 }
2771
2772 /* Delete the string between FROM and TO.  FROM is
2773    inclusive, TO is not. */
2774 rl_delete_text (from, to)
2775      int from, to;
2776 {
2777   extern int doing_an_undo;
2778   register char *text;
2779
2780   /* Fix it if the caller is confused. */
2781   if (from > to)
2782     {
2783       int t = from;
2784       from = to;
2785       to = t;
2786     }
2787   text = rl_copy (from, to);
2788   strncpy (the_line + from, the_line + to, rl_end - to);
2789
2790   /* Remember how to undo this delete. */
2791   if (!doing_an_undo)
2792     rl_add_undo (UNDO_DELETE, from, to, text);
2793   else
2794     free (text);
2795
2796   rl_end -= (to - from);
2797   the_line[rl_end] = '\0';
2798 }
2799
2800 \f
2801 /* **************************************************************** */
2802 /*                                                                  */
2803 /*                      Readline character functions                */
2804 /*                                                                  */
2805 /* **************************************************************** */
2806
2807 /* This is not a gap editor, just a stupid line input routine.  No hair
2808    is involved in writing any of the functions, and none should be. */
2809
2810 /* Note that:
2811
2812    rl_end is the place in the string that we would place '\0';
2813    i.e., it is always safe to place '\0' there.
2814
2815    rl_point is the place in the string where the cursor is.  Sometimes
2816    this is the same as rl_end.
2817
2818    Any command that is called interactively receives two arguments.
2819    The first is a count: the numeric arg pased to this command.
2820    The second is the key which invoked this command.
2821 */
2822
2823 \f
2824 /* **************************************************************** */
2825 /*                                                                  */
2826 /*                      Movement Commands                           */
2827 /*                                                                  */
2828 /* **************************************************************** */
2829
2830 /* Note that if you `optimize' the display for these functions, you cannot
2831    use said functions in other functions which do not do optimizing display.
2832    I.e., you will have to update the data base for rl_redisplay, and you
2833    might as well let rl_redisplay do that job. */
2834
2835 /* Move forward COUNT characters. */
2836 rl_forward (count)
2837      int count;
2838 {
2839   if (count < 0)
2840     rl_backward (-count);
2841   else
2842     while (count)
2843       {
2844 #if defined (VI_MODE)
2845         if (rl_point == (rl_end - (rl_editing_mode == vi_mode)))
2846 #else
2847         if (rl_point == rl_end)
2848 #endif /* VI_MODE */
2849           {
2850             ding ();
2851             return;
2852           }
2853         else
2854           rl_point++;
2855         --count;
2856       }
2857 }
2858
2859 /* Move backward COUNT characters. */
2860 rl_backward (count)
2861      int count;
2862 {
2863   if (count < 0)
2864     rl_forward (-count);
2865   else
2866     while (count)
2867       {
2868         if (!rl_point)
2869           {
2870             ding ();
2871             return;
2872           }
2873         else
2874           --rl_point;
2875         --count;
2876       }
2877 }
2878
2879 /* Move to the beginning of the line. */
2880 rl_beg_of_line ()
2881 {
2882   rl_point = 0;
2883 }
2884
2885 /* Move to the end of the line. */
2886 rl_end_of_line ()
2887 {
2888   rl_point = rl_end;
2889 }
2890
2891 /* Move forward a word.  We do what Emacs does. */
2892 rl_forward_word (count)
2893      int count;
2894 {
2895   int c;
2896
2897   if (count < 0)
2898     {
2899       rl_backward_word (-count);
2900       return;
2901     }
2902
2903   while (count)
2904     {
2905       if (rl_point == rl_end)
2906         return;
2907
2908       /* If we are not in a word, move forward until we are in one.
2909          Then, move forward until we hit a non-alphabetic character. */
2910       c = the_line[rl_point];
2911       if (!alphabetic (c))
2912         {
2913           while (++rl_point < rl_end)
2914             {
2915               c = the_line[rl_point];
2916               if (alphabetic (c)) break;
2917             }
2918         }
2919       if (rl_point == rl_end) return;
2920       while (++rl_point < rl_end)
2921         {
2922           c = the_line[rl_point];
2923           if (!alphabetic (c)) break;
2924         }
2925       --count;
2926     }
2927 }
2928
2929 /* Move backward a word.  We do what Emacs does. */
2930 rl_backward_word (count)
2931      int count;
2932 {
2933   int c;
2934
2935   if (count < 0)
2936     {
2937       rl_forward_word (-count);
2938       return;
2939     }
2940
2941   while (count)
2942     {
2943       if (!rl_point)
2944         return;
2945
2946       /* Like rl_forward_word (), except that we look at the characters
2947          just before point. */
2948
2949       c = the_line[rl_point - 1];
2950       if (!alphabetic (c))
2951         {
2952           while (--rl_point)
2953             {
2954               c = the_line[rl_point - 1];
2955               if (alphabetic (c)) break;
2956             }
2957         }
2958
2959       while (rl_point)
2960         {
2961           c = the_line[rl_point - 1];
2962           if (!alphabetic (c))
2963             break;
2964           else --rl_point;
2965         }
2966       --count;
2967     }
2968 }
2969
2970 /* Clear the current line.  Numeric argument to C-l does this. */
2971 rl_refresh_line ()
2972 {
2973   int curr_line = last_c_pos / screenwidth;
2974   extern char *term_clreol;
2975
2976   move_vert(curr_line);
2977   move_cursor_relative (0, the_line);   /* XXX is this right */
2978
2979 #ifdef __GO32__
2980   {
2981   int r, c, w;
2982   ScreenGetCursor(&r, &c);
2983   w = ScreenCols();
2984   memset(ScreenPrimary+r*w+c, 0, (w-c)*2);
2985   }
2986 #else /* __GO32__ */
2987   if (term_clreol)
2988     tputs (term_clreol, 1, output_character_function);
2989 #endif /* __GO32__/else */
2990
2991   rl_forced_update_display ();
2992   rl_display_fixed = 1;
2993 }
2994
2995 /* C-l typed to a line without quoting clears the screen, and then reprints
2996    the prompt and the current input line.  Given a numeric arg, redraw only
2997    the current line. */
2998 rl_clear_screen ()
2999 {
3000   extern char *term_clrpag;
3001
3002   if (rl_explicit_arg)
3003     {
3004       rl_refresh_line ();
3005       return;
3006     }
3007
3008 #ifndef __GO32__
3009   if (term_clrpag)
3010     tputs (term_clrpag, 1, output_character_function);
3011   else
3012 #endif /* !__GO32__ */
3013     crlf ();
3014
3015   rl_forced_update_display ();
3016   rl_display_fixed = 1;
3017 }
3018
3019 rl_arrow_keys (count, c)
3020      int count, c;
3021 {
3022   int ch;
3023
3024   ch = rl_read_key ();
3025
3026   switch (to_upper (ch))
3027     {
3028     case 'A':
3029       rl_get_previous_history (count);
3030       break;
3031
3032     case 'B':
3033       rl_get_next_history (count);
3034       break;
3035
3036     case 'C':
3037       rl_forward (count);
3038       break;
3039
3040     case 'D':
3041       rl_backward (count);
3042       break;
3043
3044     default:
3045       ding ();
3046     }
3047 }
3048
3049 \f
3050 /* **************************************************************** */
3051 /*                                                                  */
3052 /*                      Text commands                               */
3053 /*                                                                  */
3054 /* **************************************************************** */
3055
3056 /* Insert the character C at the current location, moving point forward. */
3057 rl_insert (count, c)
3058      int count, c;
3059 {
3060   register int i;
3061   char *string;
3062
3063   if (count <= 0)
3064     return;
3065
3066   /* If we can optimize, then do it.  But don't let people crash
3067      readline because of extra large arguments. */
3068   if (count > 1 && count < 1024)
3069     {
3070       string = (char *)alloca (1 + count);
3071
3072       for (i = 0; i < count; i++)
3073         string[i] = c;
3074
3075       string[i] = '\0';
3076       rl_insert_text (string);
3077       return;
3078     }
3079
3080   if (count > 1024)
3081     {
3082       int decreaser;
3083
3084       string = (char *)alloca (1024 + 1);
3085
3086       for (i = 0; i < 1024; i++)
3087         string[i] = c;
3088
3089       while (count)
3090         {
3091           decreaser = (count > 1024 ? 1024 : count);
3092           string[decreaser] = '\0';
3093           rl_insert_text (string);
3094           count -= decreaser;
3095         }
3096       return;
3097     }
3098
3099   /* We are inserting a single character.
3100      If there is pending input, then make a string of all of the
3101      pending characters that are bound to rl_insert, and insert
3102      them all. */
3103   if (any_typein)
3104     {
3105       int key = 0, t;
3106
3107       i = 0;
3108       string = (char *)alloca (ibuffer_len + 1);
3109       string[i++] = c;
3110
3111       while ((t = rl_get_char (&key)) &&
3112              (keymap[key].type == ISFUNC &&
3113               keymap[key].function == rl_insert))
3114         string[i++] = key;
3115
3116       if (t)
3117         rl_unget_char (key);
3118
3119       string[i] = '\0';
3120       rl_insert_text (string);
3121       return;
3122     }
3123   else
3124     {
3125       /* Inserting a single character. */
3126       string = (char *)alloca (2);
3127
3128       string[1] = '\0';
3129       string[0] = c;
3130       rl_insert_text (string);
3131     }
3132 }
3133
3134 /* Insert the next typed character verbatim. */
3135 rl_quoted_insert (count)
3136      int count;
3137 {
3138   int c = rl_read_key ();
3139   rl_insert (count, c);
3140 }
3141
3142 /* Insert a tab character. */
3143 rl_tab_insert (count)
3144      int count;
3145 {
3146   rl_insert (count, '\t');
3147 }
3148
3149 /* What to do when a NEWLINE is pressed.  We accept the whole line.
3150    KEY is the key that invoked this command.  I guess it could have
3151    meaning in the future. */
3152 rl_newline (count, key)
3153      int count, key;
3154 {
3155
3156   rl_done = 1;
3157
3158 #if defined (VI_MODE)
3159   {
3160     extern int vi_doing_insert;
3161     if (vi_doing_insert)
3162       {
3163         rl_end_undo_group ();
3164         vi_doing_insert = 0;
3165       }
3166   }
3167 #endif /* VI_MODE */
3168
3169   if (readline_echoing_p)
3170     {
3171       move_vert (vis_botlin);
3172       vis_botlin = 0;
3173       crlf ();
3174       fflush (out_stream);
3175       rl_display_fixed++;
3176     }
3177 }
3178
3179 rl_clean_up_for_exit ()
3180 {
3181   if (readline_echoing_p)
3182     {
3183       move_vert (vis_botlin);
3184       vis_botlin = 0;
3185       fflush (out_stream);
3186       rl_restart_output ();
3187     }
3188 }
3189
3190 /* What to do for some uppercase characters, like meta characters,
3191    and some characters appearing in emacs_ctlx_keymap.  This function
3192    is just a stub, you bind keys to it and the code in rl_dispatch ()
3193    is special cased. */
3194 rl_do_lowercase_version (ignore1, ignore2)
3195      int ignore1, ignore2;
3196 {
3197 }
3198
3199 /* Rubout the character behind point. */
3200 rl_rubout (count)
3201      int count;
3202 {
3203   if (count < 0)
3204     {
3205       rl_delete (-count);
3206       return;
3207     }
3208
3209   if (!rl_point)
3210     {
3211       ding ();
3212       return;
3213     }
3214
3215   if (count > 1)
3216     {
3217       int orig_point = rl_point;
3218       rl_backward (count);
3219       rl_kill_text (orig_point, rl_point);
3220     }
3221   else
3222     {
3223       int c = the_line[--rl_point];
3224       rl_delete_text (rl_point, rl_point + 1);
3225
3226       if (rl_point == rl_end && alphabetic (c) && last_c_pos)
3227         {
3228           backspace (1);
3229           putc (' ', out_stream);
3230           backspace (1);
3231           last_c_pos--;
3232           visible_line[last_c_pos] = '\0';
3233           rl_display_fixed++;
3234         }
3235     }
3236 }
3237
3238 /* Delete the character under the cursor.  Given a numeric argument,
3239    kill that many characters instead. */
3240 rl_delete (count, invoking_key)
3241      int count, invoking_key;
3242 {
3243   if (count < 0)
3244     {
3245       rl_rubout (-count);
3246       return;
3247     }
3248
3249   if (rl_point == rl_end)
3250     {
3251       ding ();
3252       return;
3253     }
3254
3255   if (count > 1)
3256     {
3257       int orig_point = rl_point;
3258       rl_forward (count);
3259       rl_kill_text (orig_point, rl_point);
3260       rl_point = orig_point;
3261     }
3262   else
3263     rl_delete_text (rl_point, rl_point + 1);
3264 }
3265
3266 \f
3267 /* **************************************************************** */
3268 /*                                                                  */
3269 /*                      Kill commands                               */
3270 /*                                                                  */
3271 /* **************************************************************** */
3272
3273 /* The next two functions mimic unix line editing behaviour, except they
3274    save the deleted text on the kill ring.  This is safer than not saving
3275    it, and since we have a ring, nobody should get screwed. */
3276
3277 /* This does what C-w does in Unix.  We can't prevent people from
3278    using behaviour that they expect. */
3279 rl_unix_word_rubout ()
3280 {
3281   if (!rl_point) ding ();
3282   else {
3283     int orig_point = rl_point;
3284     while (rl_point && whitespace (the_line[rl_point - 1]))
3285       rl_point--;
3286     while (rl_point && !whitespace (the_line[rl_point - 1]))
3287       rl_point--;
3288     rl_kill_text (rl_point, orig_point);
3289   }
3290 }
3291
3292 /* Here is C-u doing what Unix does.  You don't *have* to use these
3293    key-bindings.  We have a choice of killing the entire line, or
3294    killing from where we are to the start of the line.  We choose the
3295    latter, because if you are a Unix weenie, then you haven't backspaced
3296    into the line at all, and if you aren't, then you know what you are
3297    doing. */
3298 rl_unix_line_discard ()
3299 {
3300   if (!rl_point) ding ();
3301   else {
3302     rl_kill_text (rl_point, 0);
3303     rl_point = 0;
3304   }
3305 }
3306
3307 \f
3308
3309 /* **************************************************************** */
3310 /*                                                                  */
3311 /*                      Commands For Typos                          */
3312 /*                                                                  */
3313 /* **************************************************************** */
3314
3315 /* Random and interesting things in here.  */
3316
3317 /* **************************************************************** */
3318 /*                                                                  */
3319 /*                      Changing Case                               */
3320 /*                                                                  */
3321 /* **************************************************************** */
3322
3323 /* The three kinds of things that we know how to do. */
3324 #define UpCase 1
3325 #define DownCase 2
3326 #define CapCase 3
3327
3328 /* Uppercase the word at point. */
3329 rl_upcase_word (count)
3330      int count;
3331 {
3332   rl_change_case (count, UpCase);
3333 }
3334
3335 /* Lowercase the word at point. */
3336 rl_downcase_word (count)
3337      int count;
3338 {
3339   rl_change_case (count, DownCase);
3340 }
3341
3342 /* Upcase the first letter, downcase the rest. */
3343 rl_capitalize_word (count)
3344      int count;
3345 {
3346   rl_change_case (count, CapCase);
3347 }
3348
3349 /* The meaty function.
3350    Change the case of COUNT words, performing OP on them.
3351    OP is one of UpCase, DownCase, or CapCase.
3352    If a negative argument is given, leave point where it started,
3353    otherwise, leave it where it moves to. */
3354 rl_change_case (count, op)
3355      int count, op;
3356 {
3357   register int start = rl_point, end;
3358   int state = 0;
3359
3360   rl_forward_word (count);
3361   end = rl_point;
3362
3363   if (count < 0)
3364     {
3365       int temp = start;
3366       start = end;
3367       end = temp;
3368     }
3369
3370   /* We are going to modify some text, so let's prepare to undo it. */
3371   rl_modifying (start, end);
3372
3373   for (; start < end; start++)
3374     {
3375       switch (op)
3376         {
3377         case UpCase:
3378           the_line[start] = to_upper (the_line[start]);
3379           break;
3380
3381         case DownCase:
3382           the_line[start] = to_lower (the_line[start]);
3383           break;
3384
3385         case CapCase:
3386           if (state == 0)
3387             {
3388               the_line[start] = to_upper (the_line[start]);
3389               state = 1;
3390             }
3391           else
3392             {
3393               the_line[start] = to_lower (the_line[start]);
3394             }
3395           if (!pure_alphabetic (the_line[start]))
3396             state = 0;
3397           break;
3398
3399         default:
3400           abort ();
3401         }
3402     }
3403   rl_point = end;
3404 }
3405
3406 /* **************************************************************** */
3407 /*                                                                  */
3408 /*                      Transposition                               */
3409 /*                                                                  */
3410 /* **************************************************************** */
3411
3412 /* Transpose the words at point. */
3413 rl_transpose_words (count)
3414      int count;
3415 {
3416   char *word1, *word2;
3417   int w1_beg, w1_end, w2_beg, w2_end;
3418   int orig_point = rl_point;
3419
3420   if (!count) return;
3421
3422   /* Find the two words. */
3423   rl_forward_word (count);
3424   w2_end = rl_point;
3425   rl_backward_word (1);
3426   w2_beg = rl_point;
3427   rl_backward_word (count);
3428   w1_beg = rl_point;
3429   rl_forward_word (1);
3430   w1_end = rl_point;
3431
3432   /* Do some check to make sure that there really are two words. */
3433   if ((w1_beg == w2_beg) || (w2_beg < w1_end))
3434     {
3435       ding ();
3436       rl_point = orig_point;
3437       return;
3438     }
3439
3440   /* Get the text of the words. */
3441   word1 = rl_copy (w1_beg, w1_end);
3442   word2 = rl_copy (w2_beg, w2_end);
3443
3444   /* We are about to do many insertions and deletions.  Remember them
3445      as one operation. */
3446   rl_begin_undo_group ();
3447
3448   /* Do the stuff at word2 first, so that we don't have to worry
3449      about word1 moving. */
3450   rl_point = w2_beg;
3451   rl_delete_text (w2_beg, w2_end);
3452   rl_insert_text (word1);
3453
3454   rl_point = w1_beg;
3455   rl_delete_text (w1_beg, w1_end);
3456   rl_insert_text (word2);
3457
3458   /* This is exactly correct since the text before this point has not
3459      changed in length. */
3460   rl_point = w2_end;
3461
3462   /* I think that does it. */
3463   rl_end_undo_group ();
3464   free (word1); free (word2);
3465 }
3466
3467 /* Transpose the characters at point.  If point is at the end of the line,
3468    then transpose the characters before point. */
3469 rl_transpose_chars (count)
3470      int count;
3471 {
3472   if (!count)
3473     return;
3474
3475   if (!rl_point || rl_end < 2) {
3476     ding ();
3477     return;
3478   }
3479
3480   while (count)
3481     {
3482       if (rl_point == rl_end)
3483         {
3484           int t = the_line[rl_point - 1];
3485
3486           the_line[rl_point - 1] = the_line[rl_point - 2];
3487           the_line[rl_point - 2] = t;
3488         }
3489       else
3490         {
3491           int t = the_line[rl_point];
3492
3493           the_line[rl_point] = the_line[rl_point - 1];
3494           the_line[rl_point - 1] = t;
3495
3496           if (count < 0 && rl_point)
3497             rl_point--;
3498           else
3499             rl_point++;
3500         }
3501
3502       if (count < 0)
3503         count++;
3504       else
3505         count--;
3506     }
3507 }
3508
3509 \f
3510 /* **************************************************************** */
3511 /*                                                                  */
3512 /*                      Bogus Flow Control                          */
3513 /*                                                                  */
3514 /* **************************************************************** */
3515
3516 rl_restart_output (count, key)
3517      int count, key;
3518 {
3519   int fildes = fileno (rl_outstream);
3520 #if defined (TIOCSTART)
3521 #if defined (apollo)
3522   ioctl (&fildes, TIOCSTART, 0);
3523 #else
3524   ioctl (fildes, TIOCSTART, 0);
3525 #endif /* apollo */
3526
3527 #else
3528 #  if defined (TERMIOS_TTY_DRIVER)
3529         tcflow (fildes, TCOON);
3530 #  else
3531 #    if defined (TCXONC)
3532         ioctl (fildes, TCXONC, TCOON);
3533 #    endif /* TCXONC */
3534 #  endif /* !TERMIOS_TTY_DRIVER */
3535 #endif /* TIOCSTART */
3536 }
3537
3538 rl_stop_output (count, key)
3539      int count, key;
3540 {
3541   int fildes = fileno (rl_instream);
3542
3543 #if defined (TIOCSTOP)
3544 # if defined (apollo)
3545   ioctl (&fildes, TIOCSTOP, 0);
3546 # else
3547   ioctl (fildes, TIOCSTOP, 0);
3548 # endif /* apollo */
3549 #else
3550 # if defined (TERMIOS_TTY_DRIVER)
3551   tcflow (fildes, TCOOFF);
3552 # else
3553 #   if defined (TCXONC)
3554   ioctl (fildes, TCXONC, TCOON);
3555 #   endif /* TCXONC */
3556 # endif /* !TERMIOS_TTY_DRIVER */
3557 #endif /* TIOCSTOP */
3558 }
3559
3560 /* **************************************************************** */
3561 /*                                                                  */
3562 /*      Completion matching, from readline's point of view.         */
3563 /*                                                                  */
3564 /* **************************************************************** */
3565
3566 /* Pointer to the generator function for completion_matches ().
3567    NULL means to use filename_entry_function (), the default filename
3568    completer. */
3569 Function *rl_completion_entry_function = (Function *)NULL;
3570
3571 /* Pointer to alternative function to create matches.
3572    Function is called with TEXT, START, and END.
3573    START and END are indices in RL_LINE_BUFFER saying what the boundaries
3574    of TEXT are.
3575    If this function exists and returns NULL then call the value of
3576    rl_completion_entry_function to try to match, otherwise use the
3577    array of strings returned. */
3578 Function *rl_attempted_completion_function = (Function *)NULL;
3579
3580 /* Local variable states what happened during the last completion attempt. */
3581 static int completion_changed_buffer = 0;
3582
3583 /* Complete the word at or before point.  You have supplied the function
3584    that does the initial simple matching selection algorithm (see
3585    completion_matches ()).  The default is to do filename completion. */
3586
3587 rl_complete (ignore, invoking_key)
3588      int ignore, invoking_key;
3589 {
3590   if (rl_last_func == rl_complete && !completion_changed_buffer)
3591     rl_complete_internal ('?');
3592   else
3593     rl_complete_internal (TAB);
3594 }
3595
3596 /* List the possible completions.  See description of rl_complete (). */
3597 rl_possible_completions ()
3598 {
3599   rl_complete_internal ('?');
3600 }
3601
3602 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
3603 get_y_or_n ()
3604 {
3605   int c;
3606  loop:
3607   c = rl_read_key ();
3608   if (c == 'y' || c == 'Y') return (1);
3609   if (c == 'n' || c == 'N') return (0);
3610   if (c == ABORT_CHAR) rl_abort ();
3611   ding (); goto loop;
3612 }
3613
3614 /* Up to this many items will be displayed in response to a
3615    possible-completions call.  After that, we ask the user if
3616    she is sure she wants to see them all. */
3617 int rl_completion_query_items = 100;
3618
3619 /* The basic list of characters that signal a break between words for the
3620    completer routine.  The contents of this variable is what breaks words
3621    in the shell, i.e. " \t\n\"\\'`@$><=" */
3622 char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(";
3623
3624 /* The list of characters that signal a break between words for
3625    rl_complete_internal.  The default list is the contents of
3626    rl_basic_word_break_characters.  */
3627 char *rl_completer_word_break_characters = (char *)NULL;
3628
3629 /* The list of characters which are used to quote a substring of the command
3630    line.  Command completion occurs on the entire substring, and within the
3631    substring rl_completer_word_break_characters are treated as any other
3632    character, unless they also appear within this list. */
3633 char *rl_completer_quote_characters = (char *)NULL;
3634
3635 /* List of characters that are word break characters, but should be left
3636    in TEXT when it is passed to the completion function.  The shell uses
3637    this to help determine what kind of completing to do. */
3638 char *rl_special_prefixes = (char *)NULL;
3639
3640 /* If non-zero, then disallow duplicates in the matches. */
3641 int rl_ignore_completion_duplicates = 1;
3642
3643 /* Non-zero means that the results of the matches are to be treated
3644    as filenames.  This is ALWAYS zero on entry, and can only be changed
3645    within a completion entry finder function. */
3646 int rl_filename_completion_desired = 0;
3647
3648 /* This function, if defined, is called by the completer when real
3649    filename completion is done, after all the matching names have been
3650    generated. It is passed a (char**) known as matches in the code below.
3651    It consists of a NULL-terminated array of pointers to potential
3652    matching strings.  The 1st element (matches[0]) is the maximal
3653    substring that is common to all matches. This function can re-arrange
3654    the list of matches as required, but all elements of the array must be
3655    free()'d if they are deleted. The main intent of this function is
3656    to implement FIGNORE a la SunOS csh. */
3657 Function *rl_ignore_some_completions_function = (Function *)NULL;
3658
3659 /* Complete the word at or before point.
3660    WHAT_TO_DO says what to do with the completion.
3661    `?' means list the possible completions.
3662    TAB means do standard completion.
3663    `*' means insert all of the possible completions. */
3664 rl_complete_internal (what_to_do)
3665      int what_to_do;
3666 {
3667   char *filename_completion_function ();
3668   char **completion_matches (), **matches;
3669   Function *our_func;
3670   int start, scan, end, delimiter = 0;
3671   char *text, *saved_line_buffer;
3672   char quote_char = '\0';
3673   char *replacement;
3674
3675   if (the_line)
3676     saved_line_buffer = savestring (the_line);
3677   else
3678     saved_line_buffer = (char *)NULL;
3679
3680   if (rl_completion_entry_function)
3681     our_func = rl_completion_entry_function;
3682   else
3683     our_func = (int (*)())filename_completion_function;
3684
3685   /* Only the completion entry function can change this. */
3686   rl_filename_completion_desired = 0;
3687
3688   /* We now look backwards for the start of a filename/variable word. */
3689   end = rl_point;
3690
3691   if (rl_point)
3692     {
3693       if (rl_completer_quote_characters)
3694         {
3695           /* We have a list of characters which can be used in pairs to quote
3696              substrings for completion.  Try to find the start of an unclosed
3697              quoted substring.
3698              FIXME:  Doesn't yet handle '\' escapes to hid embedded quotes */
3699           for (scan = 0; scan < end; scan++)
3700             {
3701               if (quote_char != '\0')
3702                 {
3703                   /* Ignore everything until the matching close quote char */
3704                   if (the_line[scan] == quote_char)
3705                     {
3706                       /* Found matching close quote. Abandon this substring. */
3707                       quote_char = '\0';
3708                       rl_point = end;
3709                     }
3710                 }
3711               else if (rindex (rl_completer_quote_characters, the_line[scan]))
3712                 {
3713                   /* Found start of a quoted substring. */
3714                   quote_char = the_line[scan];
3715                   rl_point = scan + 1;
3716                 }
3717             }
3718         }
3719       if (rl_point == end)
3720         {
3721           /* We didn't find an unclosed quoted substring upon which to do
3722              completion, so use the word break characters to find the
3723              substring on which to do completion. */
3724           while (--rl_point &&
3725                  !rindex (rl_completer_word_break_characters,
3726                           the_line[rl_point])) {;}
3727         }
3728
3729       /* If we are at a word break, then advance past it. */
3730       if (rindex (rl_completer_word_break_characters, the_line[rl_point]))
3731         {
3732           /* If the character that caused the word break was a quoting
3733              character, then remember it as the delimiter. */
3734           if (rindex ("\"'", the_line[rl_point]) && (end - rl_point) > 1)
3735             delimiter = the_line[rl_point];
3736
3737           /* If the character isn't needed to determine something special
3738              about what kind of completion to perform, then advance past it. */
3739
3740           if (!rl_special_prefixes ||
3741               !rindex (rl_special_prefixes, the_line[rl_point]))
3742             rl_point++;
3743         }
3744     }
3745
3746   start = rl_point;
3747   rl_point = end;
3748   text = rl_copy (start, end);
3749
3750   /* If the user wants to TRY to complete, but then wants to give
3751      up and use the default completion function, they set the
3752      variable rl_attempted_completion_function. */
3753   if (rl_attempted_completion_function)
3754     {
3755       matches =
3756         (char **)(*rl_attempted_completion_function) (text, start, end);
3757
3758       if (matches)
3759         {
3760           our_func = (Function *)NULL;
3761           goto after_usual_completion;
3762         }
3763     }
3764
3765   matches = completion_matches (text, our_func);
3766
3767  after_usual_completion:
3768   free (text);
3769
3770   if (!matches)
3771     ding ();
3772   else
3773     {
3774       register int i;
3775
3776     some_matches:
3777
3778       /* It seems to me that in all the cases we handle we would like
3779          to ignore duplicate possibilities.  Scan for the text to
3780          insert being identical to the other completions. */
3781       if (rl_ignore_completion_duplicates)
3782         {
3783           char *lowest_common;
3784           int j, newlen = 0;
3785
3786           /* Sort the items. */
3787           /* It is safe to sort this array, because the lowest common
3788              denominator found in matches[0] will remain in place. */
3789           for (i = 0; matches[i]; i++);
3790           qsort (matches, i, sizeof (char *), compare_strings);
3791
3792           /* Remember the lowest common denominator for it may be unique. */
3793           lowest_common = savestring (matches[0]);
3794
3795           for (i = 0; matches[i + 1]; i++)
3796             {
3797               if (strcmp (matches[i], matches[i + 1]) == 0)
3798                 {
3799                   free (matches[i]);
3800                   matches[i] = (char *)-1;
3801                 }
3802               else
3803                 newlen++;
3804             }
3805
3806           /* We have marked all the dead slots with (char *)-1.
3807              Copy all the non-dead entries into a new array. */
3808           {
3809             char **temp_array =
3810               (char **)malloc ((3 + newlen) * sizeof (char *));
3811
3812             for (i = 1, j = 1; matches[i]; i++)
3813               {
3814                 if (matches[i] != (char *)-1)
3815                   temp_array[j++] = matches[i];
3816               }
3817
3818             temp_array[j] = (char *)NULL;
3819
3820             if (matches[0] != (char *)-1)
3821               free (matches[0]);
3822
3823             free (matches);
3824
3825             matches = temp_array;
3826           }
3827
3828           /* Place the lowest common denominator back in [0]. */
3829           matches[0] = lowest_common;
3830
3831           /* If there is one string left, and it is identical to the
3832              lowest common denominator, then the LCD is the string to
3833              insert. */
3834           if (j == 2 && strcmp (matches[0], matches[1]) == 0)
3835             {
3836               free (matches[1]);
3837               matches[1] = (char *)NULL;
3838             }
3839         }
3840
3841       switch (what_to_do)
3842         {
3843         case TAB:
3844           /* If we are matching filenames, then here is our chance to
3845              do clever processing by re-examining the list.  Call the
3846              ignore function with the array as a parameter.  It can
3847              munge the array, deleting matches as it desires. */
3848           if (rl_ignore_some_completions_function &&
3849               our_func == (int (*)())filename_completion_function)
3850             (void)(*rl_ignore_some_completions_function)(matches);
3851
3852           /* If we are doing completions on quoted substrings, and any matches
3853              contain any of the completer word break characters, then auto-
3854              matically prepend the substring with a quote character (just
3855              pick the first one from the list of such) if it does not already
3856              begin with a quote string.  FIXME:  Need to remove any such
3857              automatically inserted quote character when it no longer is
3858              necessary, such as if we change the string we are completing on
3859              and the new set of matches don't require a quoted substring? */
3860
3861           replacement = matches[0];
3862           if (matches[0] != NULL
3863               && rl_completer_quote_characters != NULL
3864               && (quote_char == '\0'))
3865             {
3866               for (i = 1; matches[i] != NULL; i++)
3867                 {
3868                   if (strpbrk (matches[i], rl_completer_word_break_characters))
3869                     {
3870                       /* Found an embedded word break character in a potential
3871                          match, so need to prepend a quote character if we are
3872                          replacing the completion string. */
3873                       replacement = alloca (strlen (matches[0]) + 2);
3874                       quote_char = *rl_completer_quote_characters;
3875                       *replacement = quote_char;
3876                       strcpy (replacement + 1, matches[0]);
3877                       break;
3878                     }
3879                 }
3880             }
3881           if (replacement)
3882             {
3883               rl_delete_text (start, rl_point);
3884               rl_point = start;
3885               rl_insert_text (replacement);
3886             }
3887
3888           /* If there are more matches, ring the bell to indicate.
3889              If this was the only match, and we are hacking files,
3890              check the file to see if it was a directory.  If so,
3891              add a '/' to the name.  If not, and we are at the end
3892              of the line, then add a space. */
3893           if (matches[1])
3894             {
3895               ding ();          /* There are other matches remaining. */
3896             }
3897           else
3898             {
3899               char temp_string[16];
3900               int temp_index = 0;
3901
3902               if (quote_char)
3903                 {
3904                   temp_string[temp_index++] = quote_char;
3905                 }
3906               temp_string[temp_index++] = delimiter ? delimiter : ' ';
3907               temp_string[temp_index++] = '\0';
3908
3909               if (rl_filename_completion_desired)
3910                 {
3911                   struct stat finfo;
3912                   char *filename = tilde_expand (matches[0]);
3913
3914                   if ((stat (filename, &finfo) == 0) &&
3915                       S_ISDIR (finfo.st_mode))
3916                     {
3917                       if (the_line[rl_point] != '/')
3918                         rl_insert_text ("/");
3919                     }
3920                   else
3921                     {
3922                       if (rl_point == rl_end)
3923                         rl_insert_text (temp_string);
3924                     }
3925                   free (filename);
3926                 }
3927               else
3928                 {
3929                   if (rl_point == rl_end)
3930                     rl_insert_text (temp_string);
3931                 }
3932             }
3933           break;
3934
3935         case '*':
3936           {
3937             int i = 1;
3938
3939             rl_delete_text (start, rl_point);
3940             rl_point = start;
3941             rl_begin_undo_group ();
3942             if (matches[1])
3943               {
3944                 while (matches[i])
3945                   {
3946                     rl_insert_text (matches[i++]);
3947                     rl_insert_text (" ");
3948                   }
3949               }
3950             else
3951               {
3952                 rl_insert_text (matches[0]);
3953                 rl_insert_text (" ");
3954               }
3955             rl_end_undo_group ();
3956           }
3957           break;
3958
3959         case '?':
3960           {
3961             int len, count, limit, max = 0;
3962             int j, k, l;
3963
3964             /* Handle simple case first.  What if there is only one answer? */
3965             if (!matches[1])
3966               {
3967                 char *temp;
3968
3969                 if (rl_filename_completion_desired)
3970                   temp = rindex (matches[0], '/');
3971                 else
3972                   temp = (char *)NULL;
3973
3974                 if (!temp)
3975                   temp = matches[0];
3976                 else
3977                   temp++;
3978
3979                 crlf ();
3980                 fprintf (out_stream, "%s", temp);
3981                 crlf ();
3982                 goto restart;
3983               }
3984
3985             /* There is more than one answer.  Find out how many there are,
3986                and find out what the maximum printed length of a single entry
3987                is. */
3988             for (i = 1; matches[i]; i++)
3989               {
3990                 char *temp = (char *)NULL;
3991
3992                 /* If we are hacking filenames, then only count the characters
3993                    after the last slash in the pathname. */
3994                 if (rl_filename_completion_desired)
3995                   temp = rindex (matches[i], '/');
3996                 else
3997                   temp = (char *)NULL;
3998
3999                 if (!temp)
4000                   temp = matches[i];
4001                 else
4002                   temp++;
4003
4004                 if (strlen (temp) > max)
4005                   max = strlen (temp);
4006               }
4007
4008             len = i;
4009
4010             /* If there are many items, then ask the user if she
4011                really wants to see them all. */
4012             if (len >= rl_completion_query_items)
4013               {
4014                 crlf ();
4015                 fprintf (out_stream,
4016                          "There are %d possibilities.  Do you really", len);
4017                 crlf ();
4018                 fprintf (out_stream, "wish to see them all? (y or n)");
4019                 fflush (out_stream);
4020                 if (!get_y_or_n ())
4021                   {
4022                     crlf ();
4023                     goto restart;
4024                   }
4025               }
4026             /* How many items of MAX length can we fit in the screen window? */
4027             max += 2;
4028             limit = screenwidth / max;
4029             if (limit != 1 && (limit * max == screenwidth))
4030               limit--;
4031
4032             /* Avoid a possible floating exception.  If max > screenwidth,
4033                limit will be 0 and a divide-by-zero fault will result. */
4034             if (limit == 0)
4035               limit = 1;
4036
4037             /* How many iterations of the printing loop? */
4038             count = (len + (limit - 1)) / limit;
4039
4040             /* Watch out for special case.  If LEN is less than LIMIT, then
4041                just do the inner printing loop. */
4042             if (len < limit) count = 1;
4043
4044             /* Sort the items if they are not already sorted. */
4045             if (!rl_ignore_completion_duplicates)
4046               qsort (matches, len, sizeof (char *), compare_strings);
4047
4048             /* Print the sorted items, up-and-down alphabetically, like
4049                ls might. */
4050             crlf ();
4051
4052             for (i = 1; i < count + 1; i++)
4053               {
4054                 for (j = 0, l = i; j < limit; j++)
4055                   {
4056                     if (l > len || !matches[l])
4057                       {
4058                         break;
4059                       }
4060                     else
4061                       {
4062                         char *temp = (char *)NULL;
4063
4064                         if (rl_filename_completion_desired)
4065                           temp = rindex (matches[l], '/');
4066                         else
4067                           temp = (char *)NULL;
4068
4069                         if (!temp)
4070                           temp = matches[l];
4071                         else
4072                           temp++;
4073
4074                         fprintf (out_stream, "%s", temp);
4075                         for (k = 0; k < max - strlen (temp); k++)
4076                           putc (' ', out_stream);
4077                       }
4078                     l += count;
4079                   }
4080                 crlf ();
4081               }
4082           restart:
4083
4084             rl_on_new_line ();
4085           }
4086           break;
4087
4088         default:
4089           abort ();
4090         }
4091
4092       for (i = 0; matches[i]; i++)
4093         free (matches[i]);
4094       free (matches);
4095     }
4096
4097   /* Check to see if the line has changed through all of this manipulation. */
4098   if (saved_line_buffer)
4099     {
4100       if (strcmp (the_line, saved_line_buffer) != 0)
4101         completion_changed_buffer = 1;
4102       else
4103         completion_changed_buffer = 0;
4104
4105       free (saved_line_buffer);
4106     }
4107 }
4108
4109 /* Stupid comparison routine for qsort () ing strings. */
4110 static int
4111 compare_strings (s1, s2)
4112   char **s1, **s2;
4113 {
4114   return (strcmp (*s1, *s2));
4115 }
4116
4117 /* A completion function for usernames.
4118    TEXT contains a partial username preceded by a random
4119    character (usually `~').  */
4120 char *
4121 username_completion_function (text, state)
4122      int state;
4123      char *text;
4124 {
4125 #ifdef __GO32__
4126   return (char *)NULL;
4127 #else /* !__GO32__ */
4128   static char *username = (char *)NULL;
4129   static struct passwd *entry;
4130   static int namelen, first_char, first_char_loc;
4131
4132   if (!state)
4133     {
4134       if (username)
4135         free (username);
4136
4137       first_char = *text;
4138
4139       if (first_char == '~')
4140         first_char_loc = 1;
4141       else
4142         first_char_loc = 0;
4143
4144       username = savestring (&text[first_char_loc]);
4145       namelen = strlen (username);
4146       setpwent ();
4147     }
4148
4149   while (entry = getpwent ())
4150     {
4151       if (strncmp (username, entry->pw_name, namelen) == 0)
4152         break;
4153     }
4154
4155   if (!entry)
4156     {
4157       endpwent ();
4158       return ((char *)NULL);
4159     }
4160   else
4161     {
4162       char *value = (char *)xmalloc (2 + strlen (entry->pw_name));
4163
4164       *value = *text;
4165
4166       strcpy (value + first_char_loc, entry->pw_name);
4167
4168       if (first_char == '~')
4169         rl_filename_completion_desired = 1;
4170
4171       return (value);
4172     }
4173 #endif /* !__GO32__ */
4174 }
4175 \f
4176 /* **************************************************************** */
4177 /*                                                                  */
4178 /*                      Undo, and Undoing                           */
4179 /*                                                                  */
4180 /* **************************************************************** */
4181
4182 /* Non-zero tells rl_delete_text and rl_insert_text to not add to
4183    the undo list. */
4184 int doing_an_undo = 0;
4185
4186 /* The current undo list for THE_LINE. */
4187 UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
4188
4189 /* Remember how to undo something.  Concatenate some undos if that
4190    seems right. */
4191 rl_add_undo (what, start, end, text)
4192      enum undo_code what;
4193      int start, end;
4194      char *text;
4195 {
4196   UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST));
4197   temp->what = what;
4198   temp->start = start;
4199   temp->end = end;
4200   temp->text = text;
4201   temp->next = rl_undo_list;
4202   rl_undo_list = temp;
4203 }
4204
4205 /* Free the existing undo list. */
4206 free_undo_list ()
4207 {
4208   while (rl_undo_list) {
4209     UNDO_LIST *release = rl_undo_list;
4210     rl_undo_list = rl_undo_list->next;
4211
4212     if (release->what == UNDO_DELETE)
4213       free (release->text);
4214
4215     free (release);
4216   }
4217 }
4218
4219 /* Undo the next thing in the list.  Return 0 if there
4220    is nothing to undo, or non-zero if there was. */
4221 int
4222 rl_do_undo ()
4223 {
4224   UNDO_LIST *release;
4225   int waiting_for_begin = 0;
4226
4227 undo_thing:
4228   if (!rl_undo_list)
4229     return (0);
4230
4231   doing_an_undo = 1;
4232
4233   switch (rl_undo_list->what) {
4234
4235     /* Undoing deletes means inserting some text. */
4236   case UNDO_DELETE:
4237     rl_point = rl_undo_list->start;
4238     rl_insert_text (rl_undo_list->text);
4239     free (rl_undo_list->text);
4240     break;
4241
4242     /* Undoing inserts means deleting some text. */
4243   case UNDO_INSERT:
4244     rl_delete_text (rl_undo_list->start, rl_undo_list->end);
4245     rl_point = rl_undo_list->start;
4246     break;
4247
4248     /* Undoing an END means undoing everything 'til we get to
4249        a BEGIN. */
4250   case UNDO_END:
4251     waiting_for_begin++;
4252     break;
4253
4254     /* Undoing a BEGIN means that we are done with this group. */
4255   case UNDO_BEGIN:
4256     if (waiting_for_begin)
4257       waiting_for_begin--;
4258     else
4259       abort ();
4260     break;
4261   }
4262
4263   doing_an_undo = 0;
4264
4265   release = rl_undo_list;
4266   rl_undo_list = rl_undo_list->next;
4267   free (release);
4268
4269   if (waiting_for_begin)
4270     goto undo_thing;
4271
4272   return (1);
4273 }
4274
4275 /* Begin a group.  Subsequent undos are undone as an atomic operation. */
4276 rl_begin_undo_group ()
4277 {
4278   rl_add_undo (UNDO_BEGIN, 0, 0, 0);
4279 }
4280
4281 /* End an undo group started with rl_begin_undo_group (). */
4282 rl_end_undo_group ()
4283 {
4284   rl_add_undo (UNDO_END, 0, 0, 0);
4285 }
4286
4287 /* Save an undo entry for the text from START to END. */
4288 rl_modifying (start, end)
4289      int start, end;
4290 {
4291   if (start > end)
4292     {
4293       int t = start;
4294       start = end;
4295       end = t;
4296     }
4297
4298   if (start != end)
4299     {
4300       char *temp = rl_copy (start, end);
4301       rl_begin_undo_group ();
4302       rl_add_undo (UNDO_DELETE, start, end, temp);
4303       rl_add_undo (UNDO_INSERT, start, end, (char *)NULL);
4304       rl_end_undo_group ();
4305     }
4306 }
4307
4308 /* Revert the current line to its previous state. */
4309 rl_revert_line ()
4310 {
4311   if (!rl_undo_list) ding ();
4312   else {
4313     while (rl_undo_list)
4314       rl_do_undo ();
4315   }
4316 }
4317
4318 /* Do some undoing of things that were done. */
4319 rl_undo_command (count)
4320 {
4321   if (count < 0) return;        /* Nothing to do. */
4322
4323   while (count)
4324     {
4325       if (rl_do_undo ())
4326         {
4327           count--;
4328         }
4329       else
4330         {
4331           ding ();
4332           break;
4333         }
4334     }
4335 }
4336 \f
4337 /* **************************************************************** */
4338 /*                                                                  */
4339 /*                      History Utilities                           */
4340 /*                                                                  */
4341 /* **************************************************************** */
4342
4343 /* We already have a history library, and that is what we use to control
4344    the history features of readline.  However, this is our local interface
4345    to the history mechanism. */
4346
4347 /* While we are editing the history, this is the saved
4348    version of the original line. */
4349 HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL;
4350
4351 /* Set the history pointer back to the last entry in the history. */
4352 start_using_history ()
4353 {
4354   using_history ();
4355   if (saved_line_for_history)
4356     free_history_entry (saved_line_for_history);
4357
4358   saved_line_for_history = (HIST_ENTRY *)NULL;
4359 }
4360
4361 /* Free the contents (and containing structure) of a HIST_ENTRY. */
4362 free_history_entry (entry)
4363      HIST_ENTRY *entry;
4364 {
4365   if (!entry) return;
4366   if (entry->line)
4367     free (entry->line);
4368   free (entry);
4369 }
4370
4371 /* Perhaps put back the current line if it has changed. */
4372 maybe_replace_line ()
4373 {
4374   HIST_ENTRY *temp = current_history ();
4375
4376   /* If the current line has changed, save the changes. */
4377   if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list))
4378     {
4379       temp = replace_history_entry (where_history (), the_line, rl_undo_list);
4380       free (temp->line);
4381       free (temp);
4382     }
4383 }
4384
4385 /* Put back the saved_line_for_history if there is one. */
4386 maybe_unsave_line ()
4387 {
4388   if (saved_line_for_history)
4389     {
4390       int line_len;
4391
4392       line_len = strlen (saved_line_for_history->line);
4393
4394       if (line_len >= rl_line_buffer_len)
4395         rl_extend_line_buffer (line_len);
4396
4397       strcpy (the_line, saved_line_for_history->line);
4398       rl_undo_list = (UNDO_LIST *)saved_line_for_history->data;
4399       free_history_entry (saved_line_for_history);
4400       saved_line_for_history = (HIST_ENTRY *)NULL;
4401       rl_end = rl_point = strlen (the_line);
4402     }
4403   else
4404     ding ();
4405 }
4406
4407 /* Save the current line in saved_line_for_history. */
4408 maybe_save_line ()
4409 {
4410   if (!saved_line_for_history)
4411     {
4412       saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY));
4413       saved_line_for_history->line = savestring (the_line);
4414       saved_line_for_history->data = (char *)rl_undo_list;
4415     }
4416 }
4417 \f
4418 /* **************************************************************** */
4419 /*                                                                  */
4420 /*                      History Commands                            */
4421 /*                                                                  */
4422 /* **************************************************************** */
4423
4424 /* Meta-< goes to the start of the history. */
4425 rl_beginning_of_history ()
4426 {
4427   rl_get_previous_history (1 + where_history ());
4428 }
4429
4430 /* Meta-> goes to the end of the history.  (The current line). */
4431 rl_end_of_history ()
4432 {
4433   maybe_replace_line ();
4434   using_history ();
4435   maybe_unsave_line ();
4436 }
4437
4438 /* Move down to the next history line. */
4439 rl_get_next_history (count)
4440      int count;
4441 {
4442   HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
4443
4444   if (count < 0)
4445     {
4446       rl_get_previous_history (-count);
4447       return;
4448     }
4449
4450   if (!count)
4451     return;
4452
4453   maybe_replace_line ();
4454
4455   while (count)
4456     {
4457       temp = next_history ();
4458       if (!temp)
4459         break;
4460       --count;
4461     }
4462
4463   if (!temp)
4464     maybe_unsave_line ();
4465   else
4466     {
4467       int line_len;
4468
4469       line_len = strlen (temp->line);
4470
4471       if (line_len >= rl_line_buffer_len)
4472         rl_extend_line_buffer (line_len);
4473
4474       strcpy (the_line, temp->line);
4475       rl_undo_list = (UNDO_LIST *)temp->data;
4476       rl_end = rl_point = strlen (the_line);
4477 #if defined (VI_MODE)
4478       if (rl_editing_mode == vi_mode)
4479         rl_point = 0;
4480 #endif /* VI_MODE */
4481     }
4482 }
4483
4484 /* Get the previous item out of our interactive history, making it the current
4485    line.  If there is no previous history, just ding. */
4486 rl_get_previous_history (count)
4487      int count;
4488 {
4489   HIST_ENTRY *old_temp = (HIST_ENTRY *)NULL;
4490   HIST_ENTRY *temp = (HIST_ENTRY *)NULL;
4491
4492   if (count < 0)
4493     {
4494       rl_get_next_history (-count);
4495       return;
4496     }
4497
4498   if (!count)
4499     return;
4500
4501   /* If we don't have a line saved, then save this one. */
4502   maybe_save_line ();
4503
4504   /* If the current line has changed, save the changes. */
4505   maybe_replace_line ();
4506
4507   while (count)
4508     {
4509       temp = previous_history ();
4510       if (!temp)
4511         break;
4512       else
4513         old_temp = temp;
4514       --count;
4515     }
4516
4517   /* If there was a large argument, and we moved back to the start of the
4518      history, that is not an error.  So use the last value found. */
4519   if (!temp && old_temp)
4520     temp = old_temp;
4521
4522   if (!temp)
4523     ding ();
4524   else
4525     {
4526       int line_len;
4527
4528       line_len = strlen (temp->line);
4529
4530       if (line_len >= rl_line_buffer_len)
4531         rl_extend_line_buffer (line_len);
4532
4533       strcpy (the_line, temp->line);
4534       rl_undo_list = (UNDO_LIST *)temp->data;
4535       rl_end = rl_point = line_len;
4536
4537 #if defined (VI_MODE)
4538       if (rl_editing_mode == vi_mode)
4539         rl_point = 0;
4540 #endif /* VI_MODE */
4541     }
4542 }
4543
4544 \f
4545 /* **************************************************************** */
4546 /*                                                                  */
4547 /*                      I-Search and Searching                      */
4548 /*                                                                  */
4549 /* **************************************************************** */
4550
4551 /* Search backwards through the history looking for a string which is typed
4552    interactively.  Start with the current line. */
4553 rl_reverse_search_history (sign, key)
4554      int sign;
4555      int key;
4556 {
4557   rl_search_history (-sign, key);
4558 }
4559
4560 /* Search forwards through the history looking for a string which is typed
4561    interactively.  Start with the current line. */
4562 rl_forward_search_history (sign, key)
4563      int sign;
4564      int key;
4565 {
4566   rl_search_history (sign, key);
4567 }
4568
4569 /* Display the current state of the search in the echo-area.
4570    SEARCH_STRING contains the string that is being searched for,
4571    DIRECTION is zero for forward, or 1 for reverse,
4572    WHERE is the history list number of the current line.  If it is
4573    -1, then this line is the starting one. */
4574 rl_display_search (search_string, reverse_p, where)
4575      char *search_string;
4576      int reverse_p, where;
4577 {
4578   char *message = (char *)NULL;
4579
4580   message =
4581     (char *)alloca (1 + (search_string ? strlen (search_string) : 0) + 30);
4582
4583   *message = '\0';
4584
4585 #if defined (NOTDEF)
4586   if (where != -1)
4587     sprintf (message, "[%d]", where + history_base);
4588 #endif /* NOTDEF */
4589
4590   strcat (message, "(");
4591
4592   if (reverse_p)
4593     strcat (message, "reverse-");
4594
4595   strcat (message, "i-search)`");
4596
4597   if (search_string)
4598     strcat (message, search_string);
4599
4600   strcat (message, "': ");
4601   rl_message (message, 0, 0);
4602   rl_redisplay ();
4603 }
4604
4605 /* Search through the history looking for an interactively typed string.
4606    This is analogous to i-search.  We start the search in the current line.
4607    DIRECTION is which direction to search; >= 0 means forward, < 0 means
4608    backwards. */
4609 rl_search_history (direction, invoking_key)
4610      int direction;
4611      int invoking_key;
4612 {
4613   /* The string that the user types in to search for. */
4614   char *search_string = (char *)alloca (128);
4615
4616   /* The current length of SEARCH_STRING. */
4617   int search_string_index;
4618
4619   /* The list of lines to search through. */
4620   char **lines;
4621
4622   /* The length of LINES. */
4623   int hlen;
4624
4625   /* Where we get LINES from. */
4626   HIST_ENTRY **hlist = history_list ();
4627
4628   register int i = 0;
4629   int orig_point = rl_point;
4630   int orig_line = where_history ();
4631   int last_found_line = orig_line;
4632   int c, done = 0;
4633
4634   /* The line currently being searched. */
4635   char *sline;
4636
4637   /* Offset in that line. */
4638   int index;
4639
4640   /* Non-zero if we are doing a reverse search. */
4641   int reverse = (direction < 0);
4642
4643   /* Create an arrary of pointers to the lines that we want to search. */
4644   maybe_replace_line ();
4645   if (hlist)
4646     for (i = 0; hlist[i]; i++);
4647
4648   /* Allocate space for this many lines, +1 for the current input line,
4649      and remember those lines. */
4650   lines = (char **)alloca ((1 + (hlen = i)) * sizeof (char *));
4651   for (i = 0; i < hlen; i++)
4652     lines[i] = hlist[i]->line;
4653
4654   if (saved_line_for_history)
4655     lines[i] = saved_line_for_history->line;
4656   else
4657     /* So I have to type it in this way instead. */
4658     {
4659       char *alloced_line;
4660
4661       /* Keep that mips alloca happy. */
4662       alloced_line = (char *)alloca (1 + strlen (the_line));
4663       lines[i] = alloced_line;
4664       strcpy (lines[i], &the_line[0]);
4665     }
4666
4667   hlen++;
4668
4669   /* The line where we start the search. */
4670   i = orig_line;
4671
4672   /* Initialize search parameters. */
4673   *search_string = '\0';
4674   search_string_index = 0;
4675
4676   /* Normalize DIRECTION into 1 or -1. */
4677   if (direction >= 0)
4678     direction = 1;
4679   else
4680     direction = -1;
4681
4682   rl_display_search (search_string, reverse, -1);
4683
4684   sline = the_line;
4685   index = rl_point;
4686
4687   while (!done)
4688     {
4689       c = rl_read_key ();
4690
4691       /* Hack C to Do What I Mean. */
4692       {
4693         Function *f = (Function *)NULL;
4694
4695         if (keymap[c].type == ISFUNC)
4696           {
4697             f = keymap[c].function;
4698
4699             if (f == rl_reverse_search_history)
4700               c = reverse ? -1 : -2;
4701             else if (f == rl_forward_search_history)
4702               c =  !reverse ? -1 : -2;
4703           }
4704       }
4705
4706       switch (c)
4707         {
4708         case ESC:
4709           done = 1;
4710           continue;
4711
4712           /* case invoking_key: */
4713         case -1:
4714           goto search_again;
4715
4716           /* switch directions */
4717         case -2:
4718           direction = -direction;
4719           reverse = (direction < 0);
4720
4721           goto do_search;
4722
4723         case CTRL ('G'):
4724           strcpy (the_line, lines[orig_line]);
4725           rl_point = orig_point;
4726           rl_end = strlen (the_line);
4727           rl_clear_message ();
4728           return;
4729
4730         default:
4731           if (c < 32 || c > 126)
4732             {
4733               rl_execute_next (c);
4734               done = 1;
4735               continue;
4736             }
4737           else
4738             {
4739               search_string[search_string_index++] = c;
4740               search_string[search_string_index] = '\0';
4741               goto do_search;
4742
4743             search_again:
4744
4745               if (!search_string_index)
4746                 continue;
4747               else
4748                 {
4749                   if (reverse)
4750                     --index;
4751                   else
4752                     if (index != strlen (sline))
4753                       ++index;
4754                     else
4755                       ding ();
4756                 }
4757             do_search:
4758
4759               while (1)
4760                 {
4761                   if (reverse)
4762                     {
4763                       while (index >= 0)
4764                         if (strncmp
4765                             (search_string, sline + index, search_string_index)
4766                             == 0)
4767                           goto string_found;
4768                         else
4769                           index--;
4770                     }
4771                   else
4772                     {
4773                       register int limit =
4774                         (strlen (sline) - search_string_index) + 1;
4775
4776                       while (index < limit)
4777                         {
4778                           if (strncmp (search_string,
4779                                        sline + index,
4780                                        search_string_index) == 0)
4781                             goto string_found;
4782                           index++;
4783                         }
4784                     }
4785
4786                 next_line:
4787                   i += direction;
4788
4789                   /* At limit for direction? */
4790                   if ((reverse && i < 0) ||
4791                       (!reverse && i == hlen))
4792                     goto search_failed;
4793
4794                   sline = lines[i];
4795                   if (reverse)
4796                     index = strlen (sline);
4797                   else
4798                     index = 0;
4799
4800                   /* If the search string is longer than the current
4801                      line, no match. */
4802                   if (search_string_index > strlen (sline))
4803                     goto next_line;
4804
4805                   /* Start actually searching. */
4806                   if (reverse)
4807                     index -= search_string_index;
4808                 }
4809
4810             search_failed:
4811               /* We cannot find the search string.  Ding the bell. */
4812               ding ();
4813               i = last_found_line;
4814               break;
4815
4816             string_found:
4817               /* We have found the search string.  Just display it.  But don't
4818                  actually move there in the history list until the user accepts
4819                  the location. */
4820               {
4821                 int line_len;
4822
4823                 line_len = strlen (lines[i]);
4824
4825                 if (line_len >= rl_line_buffer_len)
4826                   rl_extend_line_buffer (line_len);
4827
4828                 strcpy (the_line, lines[i]);
4829                 rl_point = index;
4830                 rl_end = line_len;
4831                 last_found_line = i;
4832                 rl_display_search
4833                   (search_string, reverse, (i == orig_line) ? -1 : i);
4834               }
4835             }
4836         }
4837       continue;
4838     }
4839
4840   /* The searching is over.  The user may have found the string that she
4841      was looking for, or else she may have exited a failing search.  If
4842      INDEX is -1, then that shows that the string searched for was not
4843      found.  We use this to determine where to place rl_point. */
4844   {
4845     int now = last_found_line;
4846
4847     /* First put back the original state. */
4848     strcpy (the_line, lines[orig_line]);
4849
4850     if (now < orig_line)
4851       rl_get_previous_history (orig_line - now);
4852     else
4853       rl_get_next_history (now - orig_line);
4854
4855     /* If the index of the "matched" string is less than zero, then the
4856        final search string was never matched, so put point somewhere
4857        reasonable. */
4858     if (index < 0)
4859       index = strlen (the_line);
4860
4861     rl_point = index;
4862     rl_clear_message ();
4863   }
4864 }
4865
4866 /* Make C be the next command to be executed. */
4867 rl_execute_next (c)
4868      int c;
4869 {
4870   rl_pending_input = c;
4871 }
4872 \f
4873 /* **************************************************************** */
4874 /*                                                                  */
4875 /*                      Killing Mechanism                           */
4876 /*                                                                  */
4877 /* **************************************************************** */
4878
4879 /* What we assume for a max number of kills. */
4880 #define DEFAULT_MAX_KILLS 10
4881
4882 /* The real variable to look at to find out when to flush kills. */
4883 int rl_max_kills = DEFAULT_MAX_KILLS;
4884
4885 /* Where to store killed text. */
4886 char **rl_kill_ring = (char **)NULL;
4887
4888 /* Where we are in the kill ring. */
4889 int rl_kill_index = 0;
4890
4891 /* How many slots we have in the kill ring. */
4892 int rl_kill_ring_length = 0;
4893
4894 /* How to say that you only want to save a certain amount
4895    of kill material. */
4896 rl_set_retained_kills (num)
4897      int num;
4898 {}
4899
4900 /* The way to kill something.  This appends or prepends to the last
4901    kill, if the last command was a kill command.  if FROM is less
4902    than TO, then the text is appended, otherwise prepended.  If the
4903    last command was not a kill command, then a new slot is made for
4904    this kill. */
4905 rl_kill_text (from, to)
4906      int from, to;
4907 {
4908   int slot;
4909   char *text = rl_copy (from, to);
4910
4911   /* Is there anything to kill? */
4912   if (from == to)
4913     {
4914       free (text);
4915       last_command_was_kill++;
4916       return;
4917     }
4918
4919   /* Delete the copied text from the line. */
4920   rl_delete_text (from, to);
4921
4922   /* First, find the slot to work with. */
4923   if (!last_command_was_kill)
4924     {
4925       /* Get a new slot.  */
4926       if (!rl_kill_ring)
4927         {
4928           /* If we don't have any defined, then make one. */
4929           rl_kill_ring = (char **)
4930             xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
4931           slot = 1;
4932         }
4933       else
4934         {
4935           /* We have to add a new slot on the end, unless we have
4936              exceeded the max limit for remembering kills. */
4937           slot = rl_kill_ring_length;
4938           if (slot == rl_max_kills)
4939             {
4940               register int i;
4941               free (rl_kill_ring[0]);
4942               for (i = 0; i < slot; i++)
4943                 rl_kill_ring[i] = rl_kill_ring[i + 1];
4944             }
4945           else
4946             {
4947               rl_kill_ring =
4948                 (char **)
4949                   xrealloc (rl_kill_ring,
4950                             ((slot = (rl_kill_ring_length += 1)) + 1)
4951                             * sizeof (char *));
4952             }
4953         }
4954       slot--;
4955     }
4956   else
4957     {
4958       slot = rl_kill_ring_length - 1;
4959     }
4960
4961   /* If the last command was a kill, prepend or append. */
4962   if (last_command_was_kill && rl_editing_mode != vi_mode)
4963     {
4964       char *old = rl_kill_ring[slot];
4965       char *new = (char *)xmalloc (1 + strlen (old) + strlen (text));
4966
4967       if (from < to)
4968         {
4969           strcpy (new, old);
4970           strcat (new, text);
4971         }
4972       else
4973         {
4974           strcpy (new, text);
4975           strcat (new, old);
4976         }
4977       free (old);
4978       free (text);
4979       rl_kill_ring[slot] = new;
4980     }
4981   else
4982     {
4983       rl_kill_ring[slot] = text;
4984     }
4985   rl_kill_index = slot;
4986   last_command_was_kill++;
4987 }
4988
4989 /* Now REMEMBER!  In order to do prepending or appending correctly, kill
4990    commands always make rl_point's original position be the FROM argument,
4991    and rl_point's extent be the TO argument. */
4992
4993 /* **************************************************************** */
4994 /*                                                                  */
4995 /*                      Killing Commands                            */
4996 /*                                                                  */
4997 /* **************************************************************** */
4998
4999 /* Delete the word at point, saving the text in the kill ring. */
5000 rl_kill_word (count)
5001      int count;
5002 {
5003   int orig_point = rl_point;
5004
5005   if (count < 0)
5006     rl_backward_kill_word (-count);
5007   else
5008     {
5009       rl_forward_word (count);
5010
5011       if (rl_point != orig_point)
5012         rl_kill_text (orig_point, rl_point);
5013
5014       rl_point = orig_point;
5015     }
5016 }
5017
5018 /* Rubout the word before point, placing it on the kill ring. */
5019 rl_backward_kill_word (count)
5020      int count;
5021 {
5022   int orig_point = rl_point;
5023
5024   if (count < 0)
5025     rl_kill_word (-count);
5026   else
5027     {
5028       rl_backward_word (count);
5029
5030       if (rl_point != orig_point)
5031         rl_kill_text (orig_point, rl_point);
5032     }
5033 }
5034
5035 /* Kill from here to the end of the line.  If DIRECTION is negative, kill
5036    back to the line start instead. */
5037 rl_kill_line (direction)
5038      int direction;
5039 {
5040   int orig_point = rl_point;
5041
5042   if (direction < 0)
5043     rl_backward_kill_line (1);
5044   else
5045     {
5046       rl_end_of_line ();
5047       if (orig_point != rl_point)
5048         rl_kill_text (orig_point, rl_point);
5049       rl_point = orig_point;
5050     }
5051 }
5052
5053 /* Kill backwards to the start of the line.  If DIRECTION is negative, kill
5054    forwards to the line end instead. */
5055 rl_backward_kill_line (direction)
5056      int direction;
5057 {
5058   int orig_point = rl_point;
5059
5060   if (direction < 0)
5061     rl_kill_line (1);
5062   else
5063     {
5064       if (!rl_point)
5065         ding ();
5066       else
5067         {
5068           rl_beg_of_line ();
5069           rl_kill_text (orig_point, rl_point);
5070         }
5071     }
5072 }
5073
5074 /* Yank back the last killed text.  This ignores arguments. */
5075 rl_yank ()
5076 {
5077   if (!rl_kill_ring) rl_abort ();
5078   rl_insert_text (rl_kill_ring[rl_kill_index]);
5079 }
5080
5081 /* If the last command was yank, or yank_pop, and the text just
5082    before point is identical to the current kill item, then
5083    delete that text from the line, rotate the index down, and
5084    yank back some other text. */
5085 rl_yank_pop ()
5086 {
5087   int l;
5088
5089   if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
5090       !rl_kill_ring)
5091     {
5092       rl_abort ();
5093     }
5094
5095   l = strlen (rl_kill_ring[rl_kill_index]);
5096   if (((rl_point - l) >= 0) &&
5097       (strncmp (the_line + (rl_point - l),
5098                 rl_kill_ring[rl_kill_index], l) == 0))
5099     {
5100       rl_delete_text ((rl_point - l), rl_point);
5101       rl_point -= l;
5102       rl_kill_index--;
5103       if (rl_kill_index < 0)
5104         rl_kill_index = rl_kill_ring_length - 1;
5105       rl_yank ();
5106     }
5107   else
5108     rl_abort ();
5109
5110 }
5111
5112 /* Yank the COUNTth argument from the previous history line. */
5113 rl_yank_nth_arg (count, ignore)
5114      int count;
5115 {
5116   register HIST_ENTRY *entry = previous_history ();
5117   char *arg;
5118
5119   if (entry)
5120     next_history ();
5121   else
5122     {
5123       ding ();
5124       return;
5125     }
5126
5127   arg = history_arg_extract (count, count, entry->line);
5128   if (!arg || !*arg)
5129     {
5130       ding ();
5131       return;
5132     }
5133
5134   rl_begin_undo_group ();
5135
5136 #if defined (VI_MODE)
5137   /* Vi mode always inserts a space befoe yanking the argument, and it
5138      inserts it right *after* rl_point. */
5139   if (rl_editing_mode == vi_mode)
5140     rl_point++;
5141 #endif /* VI_MODE */
5142
5143   if (rl_point && the_line[rl_point - 1] != ' ')
5144     rl_insert_text (" ");
5145
5146   rl_insert_text (arg);
5147   free (arg);
5148
5149   rl_end_undo_group ();
5150 }
5151
5152 /* How to toggle back and forth between editing modes. */
5153 rl_vi_editing_mode ()
5154 {
5155 #if defined (VI_MODE)
5156   rl_editing_mode = vi_mode;
5157   rl_vi_insertion_mode ();
5158 #endif /* VI_MODE */
5159 }
5160
5161 rl_emacs_editing_mode ()
5162 {
5163   rl_editing_mode = emacs_mode;
5164   keymap = emacs_standard_keymap;
5165 }
5166
5167 \f
5168 /* **************************************************************** */
5169 /*                                                                  */
5170 /*                           Completion                             */
5171 /*                                                                  */
5172 /* **************************************************************** */
5173
5174 /* Non-zero means that case is not significant in completion. */
5175 int completion_case_fold = 0;
5176
5177 /* Return an array of (char *) which is a list of completions for TEXT.
5178    If there are no completions, return a NULL pointer.
5179    The first entry in the returned array is the substitution for TEXT.
5180    The remaining entries are the possible completions.
5181    The array is terminated with a NULL pointer.
5182
5183    ENTRY_FUNCTION is a function of two args, and returns a (char *).
5184      The first argument is TEXT.
5185      The second is a state argument; it should be zero on the first call, and
5186      non-zero on subsequent calls.  It returns a NULL pointer to the caller
5187      when there are no more matches.
5188  */
5189 char **
5190 completion_matches (text, entry_function)
5191      char *text;
5192      char *(*entry_function) ();
5193 {
5194   /* Number of slots in match_list. */
5195   int match_list_size;
5196
5197   /* The list of matches. */
5198   char **match_list =
5199     (char **)xmalloc (((match_list_size = 10) + 1) * sizeof (char *));
5200
5201   /* Number of matches actually found. */
5202   int matches = 0;
5203
5204   /* Temporary string binder. */
5205   char *string;
5206
5207   match_list[1] = (char *)NULL;
5208
5209   while (string = (*entry_function) (text, matches))
5210     {
5211       if (matches + 1 == match_list_size)
5212         match_list = (char **)xrealloc
5213           (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
5214
5215       match_list[++matches] = string;
5216       match_list[matches + 1] = (char *)NULL;
5217     }
5218
5219   /* If there were any matches, then look through them finding out the
5220      lowest common denominator.  That then becomes match_list[0]. */
5221   if (matches)
5222     {
5223       register int i = 1;
5224       int low = 100000;         /* Count of max-matched characters. */
5225
5226       /* If only one match, just use that. */
5227       if (matches == 1)
5228         {
5229           match_list[0] = match_list[1];
5230           match_list[1] = (char *)NULL;
5231         }
5232       else
5233         {
5234           /* Otherwise, compare each member of the list with
5235              the next, finding out where they stop matching. */
5236
5237           while (i < matches)
5238             {
5239               register int c1, c2, si;
5240
5241               if (completion_case_fold)
5242                 {
5243                   for (si = 0;
5244                        (c1 = to_lower(match_list[i][si])) &&
5245                        (c2 = to_lower(match_list[i + 1][si]));
5246                        si++)
5247                     if (c1 != c2) break;
5248                 }
5249               else
5250                 {
5251                   for (si = 0;
5252                        (c1 = match_list[i][si]) &&
5253                        (c2 = match_list[i + 1][si]);
5254                        si++)
5255                     if (c1 != c2) break;
5256                 }
5257
5258               if (low > si) low = si;
5259               i++;
5260             }
5261           match_list[0] = (char *)xmalloc (low + 1);
5262           strncpy (match_list[0], match_list[1], low);
5263           match_list[0][low] = '\0';
5264         }
5265     }
5266   else                          /* There were no matches. */
5267     {
5268       free (match_list);
5269       match_list = (char **)NULL;
5270     }
5271   return (match_list);
5272 }
5273
5274 /* Okay, now we write the entry_function for filename completion.  In the
5275    general case.  Note that completion in the shell is a little different
5276    because of all the pathnames that must be followed when looking up the
5277    completion for a command. */
5278 char *
5279 filename_completion_function (text, state)
5280      int state;
5281      char *text;
5282 {
5283   static DIR *directory;
5284   static char *filename = (char *)NULL;
5285   static char *dirname = (char *)NULL;
5286   static char *users_dirname = (char *)NULL;
5287   static int filename_len;
5288
5289   dirent *entry = (dirent *)NULL;
5290
5291   /* If we don't have any state, then do some initialization. */
5292   if (!state)
5293     {
5294       char *temp;
5295
5296       if (dirname) free (dirname);
5297       if (filename) free (filename);
5298       if (users_dirname) free (users_dirname);
5299
5300       filename = savestring (text);
5301       if (!*text) text = ".";
5302       dirname = savestring (text);
5303
5304       temp = rindex (dirname, '/');
5305
5306       if (temp)
5307         {
5308           strcpy (filename, ++temp);
5309           *temp = '\0';
5310         }
5311       else
5312         strcpy (dirname, ".");
5313
5314       /* We aren't done yet.  We also support the "~user" syntax. */
5315
5316       /* Save the version of the directory that the user typed. */
5317       users_dirname = savestring (dirname);
5318       {
5319         char *temp_dirname;
5320
5321         temp_dirname = tilde_expand (dirname);
5322         free (dirname);
5323         dirname = temp_dirname;
5324
5325         if (rl_symbolic_link_hook)
5326           (*rl_symbolic_link_hook) (&dirname);
5327       }
5328       directory = opendir (dirname);
5329       filename_len = strlen (filename);
5330
5331       rl_filename_completion_desired = 1;
5332     }
5333
5334   /* At this point we should entertain the possibility of hacking wildcarded
5335      filenames, like /usr/man/man<WILD>/te<TAB>.  If the directory name
5336      contains globbing characters, then build an array of directories to
5337      glob on, and glob on the first one. */
5338
5339   /* Now that we have some state, we can read the directory. */
5340
5341   while (directory && (entry = readdir (directory)))
5342     {
5343       /* Special case for no filename.
5344          All entries except "." and ".." match. */
5345       if (!filename_len)
5346         {
5347           if ((strcmp (entry->d_name, ".") != 0) &&
5348               (strcmp (entry->d_name, "..") != 0))
5349             break;
5350         }
5351       else
5352         {
5353           /* Otherwise, if these match upto the length of filename, then
5354              it is a match. */
5355             if (entry->d_name[0] == filename[0] && /* Quick test */
5356                 (strncmp (filename, entry->d_name, filename_len) == 0))
5357               {
5358                 break;
5359               }
5360         }
5361     }
5362
5363   if (!entry)
5364     {
5365       if (directory)
5366         {
5367           closedir (directory);
5368           directory = (DIR *)NULL;
5369         }
5370       return (char *)NULL;
5371     }
5372   else
5373     {
5374       char *temp;
5375
5376       if (dirname && (strcmp (dirname, ".") != 0))
5377         {
5378           temp = (char *)
5379             xmalloc (1 + strlen (users_dirname) + strlen (entry->d_name));
5380           strcpy (temp, users_dirname);
5381           strcat (temp, entry->d_name);
5382         }
5383       else
5384         {
5385           temp = (savestring (entry->d_name));
5386         }
5387       return (temp);
5388     }
5389 }
5390
5391 \f
5392 /* **************************************************************** */
5393 /*                                                                  */
5394 /*                      Binding keys                                */
5395 /*                                                                  */
5396 /* **************************************************************** */
5397
5398 /* rl_add_defun (char *name, Function *function, int key)
5399    Add NAME to the list of named functions.  Make FUNCTION
5400    be the function that gets called.
5401    If KEY is not -1, then bind it. */
5402 rl_add_defun (name, function, key)
5403      char *name;
5404      Function *function;
5405      int key;
5406 {
5407   if (key != -1)
5408     rl_bind_key (key, function);
5409   rl_add_funmap_entry (name, function);
5410 }
5411
5412 /* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
5413 int
5414 rl_bind_key (key, function)
5415      int key;
5416      Function *function;
5417 {
5418   if (key < 0)
5419     return (key);
5420
5421   if (key > 127 && key < 256)
5422     {
5423       if (keymap[ESC].type == ISKMAP)
5424         {
5425           Keymap escmap = (Keymap)keymap[ESC].function;
5426
5427           key -= 128;
5428           escmap[key].type = ISFUNC;
5429           escmap[key].function = function;
5430           return (0);
5431         }
5432       return (key);
5433     }
5434
5435   keymap[key].type = ISFUNC;
5436   keymap[key].function = function;
5437  return (0);
5438 }
5439
5440 /* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
5441    KEY. */
5442 int
5443 rl_bind_key_in_map (key, function, map)
5444      int key;
5445      Function *function;
5446      Keymap map;
5447 {
5448   int result;
5449   Keymap oldmap = keymap;
5450
5451   keymap = map;
5452   result = rl_bind_key (key, function);
5453   keymap = oldmap;
5454   return (result);
5455 }
5456
5457 /* Make KEY do nothing in the currently selected keymap.
5458    Returns non-zero in case of error. */
5459 int
5460 rl_unbind_key (key)
5461      int key;
5462 {
5463   return (rl_bind_key (key, (Function *)NULL));
5464 }
5465
5466 /* Make KEY do nothing in MAP.
5467    Returns non-zero in case of error. */
5468 int
5469 rl_unbind_key_in_map (key, map)
5470      int key;
5471      Keymap map;
5472 {
5473   return (rl_bind_key_in_map (key, (Function *)NULL, map));
5474 }
5475
5476 /* Bind the key sequence represented by the string KEYSEQ to
5477    FUNCTION.  This makes new keymaps as necessary.  The initial
5478    place to do bindings is in MAP. */
5479 rl_set_key (keyseq, function, map)
5480      char *keyseq;
5481      Function *function;
5482      Keymap map;
5483 {
5484   rl_generic_bind (ISFUNC, keyseq, function, map);
5485 }
5486
5487 /* Bind the key sequence represented by the string KEYSEQ to
5488    the string of characters MACRO.  This makes new keymaps as
5489    necessary.  The initial place to do bindings is in MAP. */
5490 rl_macro_bind (keyseq, macro, map)
5491      char *keyseq, *macro;
5492      Keymap map;
5493 {
5494   char *macro_keys;
5495   int macro_keys_len;
5496
5497   macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1);
5498
5499   if (rl_translate_keyseq (macro, macro_keys, &macro_keys_len))
5500     {
5501       free (macro_keys);
5502       return;
5503     }
5504   rl_generic_bind (ISMACR, keyseq, macro_keys, map);
5505 }
5506
5507 /* Bind the key sequence represented by the string KEYSEQ to
5508    the arbitrary pointer DATA.  TYPE says what kind of data is
5509    pointed to by DATA, right now this can be a function (ISFUNC),
5510    a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
5511    as necessary.  The initial place to do bindings is in MAP. */
5512 rl_generic_bind (type, keyseq, data, map)
5513      int type;
5514      char *keyseq, *data;
5515      Keymap map;
5516 {
5517   char *keys;
5518   int keys_len;
5519   register int i;
5520
5521   /* If no keys to bind to, exit right away. */
5522   if (!keyseq || !*keyseq)
5523     {
5524       if (type == ISMACR)
5525         free (data);
5526       return;
5527     }
5528
5529   keys = (char *)alloca (1 + (2 * strlen (keyseq)));
5530
5531   /* Translate the ASCII representation of KEYSEQ into an array
5532      of characters.  Stuff the characters into ARRAY, and the
5533      length of ARRAY into LENGTH. */
5534   if (rl_translate_keyseq (keyseq, keys, &keys_len))
5535     return;
5536
5537   /* Bind keys, making new keymaps as necessary. */
5538   for (i = 0; i < keys_len; i++)
5539     {
5540       if (i + 1 < keys_len)
5541         {
5542           if (map[keys[i]].type != ISKMAP)
5543             {
5544               if (map[i].type == ISMACR)
5545                 free ((char *)map[i].function);
5546
5547               map[keys[i]].type = ISKMAP;
5548               map[keys[i]].function = (Function *)rl_make_bare_keymap ();
5549             }
5550           map = (Keymap)map[keys[i]].function;
5551         }
5552       else
5553         {
5554           if (map[keys[i]].type == ISMACR)
5555             free ((char *)map[keys[i]].function);
5556
5557           map[keys[i]].function = (Function *)data;
5558           map[keys[i]].type = type;
5559         }
5560     }
5561 }
5562
5563 /* Translate the ASCII representation of SEQ, stuffing the
5564    values into ARRAY, an array of characters.  LEN gets the
5565    final length of ARRAY.  Return non-zero if there was an
5566    error parsing SEQ. */
5567 rl_translate_keyseq (seq, array, len)
5568      char *seq, *array;
5569      int *len;
5570 {
5571   register int i, c, l = 0;
5572
5573   for (i = 0; c = seq[i]; i++)
5574     {
5575       if (c == '\\')
5576         {
5577           c = seq[++i];
5578
5579           if (!c)
5580             break;
5581
5582           if (((c == 'C' || c == 'M') &&  seq[i + 1] == '-') ||
5583               (c == 'e'))
5584             {
5585               /* Handle special case of backwards define. */
5586               if (strncmp (&seq[i], "C-\\M-", 5) == 0)
5587                 {
5588                   array[l++] = ESC;
5589                   i += 5;
5590                   array[l++] = CTRL (to_upper (seq[i]));
5591                   if (!seq[i])
5592                     i--;
5593                   continue;
5594                 }
5595
5596               switch (c)
5597                 {
5598                 case 'M':
5599                   i++;
5600                   array[l++] = ESC;
5601                   break;
5602
5603                 case 'C':
5604                   i += 2;
5605                   /* Special hack for C-?... */
5606                   if (seq[i] == '?')
5607                     array[l++] = RUBOUT;
5608                   else
5609                     array[l++] = CTRL (to_upper (seq[i]));
5610                   break;
5611
5612                 case 'e':
5613                   array[l++] = ESC;
5614                 }
5615
5616               continue;
5617             }
5618         }
5619       array[l++] = c;
5620     }
5621
5622   *len = l;
5623   array[l] = '\0';
5624   return (0);
5625 }
5626
5627 /* Return a pointer to the function that STRING represents.
5628    If STRING doesn't have a matching function, then a NULL pointer
5629    is returned. */
5630 Function *
5631 rl_named_function (string)
5632      char *string;
5633 {
5634   register int i;
5635
5636   for (i = 0; funmap[i]; i++)
5637     if (stricmp (funmap[i]->name, string) == 0)
5638       return (funmap[i]->function);
5639   return ((Function *)NULL);
5640 }
5641
5642 /* The last key bindings file read. */
5643 #ifdef __MSDOS__
5644 /* Don't know what to do, but this is a guess */
5645 static char *last_readline_init_file = "/INPUTRC";
5646 #else
5647 static char *last_readline_init_file = "~/inputrc";
5648 #endif
5649
5650 /* Re-read the current keybindings file. */
5651 rl_re_read_init_file (count, ignore)
5652      int count, ignore;
5653 {
5654   rl_read_init_file ((char *)NULL);
5655 }
5656
5657 /* Do key bindings from a file.  If FILENAME is NULL it defaults
5658    to `~/.inputrc'.  If the file existed and could be opened and
5659    read, 0 is returned, otherwise errno is returned. */
5660 int
5661 rl_read_init_file (filename)
5662      char *filename;
5663 {
5664   register int i;
5665   char *buffer, *openname, *line, *end;
5666   struct stat finfo;
5667   int file;
5668
5669   /* Default the filename. */
5670   if (!filename)
5671     filename = last_readline_init_file;
5672
5673   openname = tilde_expand (filename);
5674
5675   if (!openname || *openname == '\000')
5676     return ENOENT;
5677
5678   if ((stat (openname, &finfo) < 0) ||
5679       (file = open (openname, O_RDONLY, 0666)) < 0)
5680     {
5681       free (openname);
5682       return (errno);
5683     }
5684   else
5685     free (openname);
5686
5687   last_readline_init_file = filename;
5688
5689   /* Read the file into BUFFER. */
5690   buffer = (char *)xmalloc (finfo.st_size + 1);
5691   i = read (file, buffer, finfo.st_size);
5692   close (file);
5693
5694   if (i != finfo.st_size)
5695     return (errno);
5696
5697   /* Loop over the lines in the file.  Lines that start with `#' are
5698      comments; all other lines are commands for readline initialization. */
5699   line = buffer;
5700   end = buffer + finfo.st_size;
5701   while (line < end)
5702     {
5703       /* Find the end of this line. */
5704       for (i = 0; line + i != end && line[i] != '\n'; i++);
5705
5706       /* Mark end of line. */
5707       line[i] = '\0';
5708
5709       /* If the line is not a comment, then parse it. */
5710       if (*line != '#')
5711         rl_parse_and_bind (line);
5712
5713       /* Move to the next line. */
5714       line += i + 1;
5715     }
5716   return (0);
5717 }
5718
5719 /* **************************************************************** */
5720 /*                                                                  */
5721 /*                      Parser Directives                           */
5722 /*                                                                  */
5723 /* **************************************************************** */
5724
5725 /* Conditionals. */
5726
5727 /* Calling programs set this to have their argv[0]. */
5728 char *rl_readline_name = "other";
5729
5730 /* Stack of previous values of parsing_conditionalized_out. */
5731 static unsigned char *if_stack = (unsigned char *)NULL;
5732 static int if_stack_depth = 0;
5733 static int if_stack_size = 0;
5734
5735 /* Push parsing_conditionalized_out, and set parser state based on ARGS. */
5736 parser_if (args)
5737      char *args;
5738 {
5739   register int i;
5740
5741   /* Push parser state. */
5742   if (if_stack_depth + 1 >= if_stack_size)
5743     {
5744       if (!if_stack)
5745         if_stack = (unsigned char *)xmalloc (if_stack_size = 20);
5746       else
5747         if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20);
5748     }
5749   if_stack[if_stack_depth++] = parsing_conditionalized_out;
5750
5751   /* If parsing is turned off, then nothing can turn it back on except
5752      for finding the matching endif.  In that case, return right now. */
5753   if (parsing_conditionalized_out)
5754     return;
5755
5756   /* Isolate first argument. */
5757   for (i = 0; args[i] && !whitespace (args[i]); i++);
5758
5759   if (args[i])
5760     args[i++] = '\0';
5761
5762   /* Handle "if term=foo" and "if mode=emacs" constructs.  If this
5763      isn't term=foo, or mode=emacs, then check to see if the first
5764      word in ARGS is the same as the value stored in rl_readline_name. */
5765   if (rl_terminal_name && strnicmp (args, "term=", 5) == 0)
5766     {
5767       char *tem, *tname;
5768
5769       /* Terminals like "aaa-60" are equivalent to "aaa". */
5770       tname = savestring (rl_terminal_name);
5771       tem = rindex (tname, '-');
5772       if (tem)
5773         *tem = '\0';
5774
5775       if (stricmp (args + 5, tname) == 0)
5776         parsing_conditionalized_out = 0;
5777       else
5778         parsing_conditionalized_out = 1;
5779     }
5780 #if defined (VI_MODE)
5781   else if (strnicmp (args, "mode=", 5) == 0)
5782     {
5783       int mode;
5784
5785       if (stricmp (args + 5, "emacs") == 0)
5786         mode = emacs_mode;
5787       else if (stricmp (args + 5, "vi") == 0)
5788         mode = vi_mode;
5789       else
5790         mode = no_mode;
5791
5792       if (mode == rl_editing_mode)
5793         parsing_conditionalized_out = 0;
5794       else
5795         parsing_conditionalized_out = 1;
5796     }
5797 #endif /* VI_MODE */
5798   /* Check to see if the first word in ARGS is the same as the
5799      value stored in rl_readline_name. */
5800   else if (stricmp (args, rl_readline_name) == 0)
5801     parsing_conditionalized_out = 0;
5802   else
5803     parsing_conditionalized_out = 1;
5804 }
5805
5806 /* Invert the current parser state if there is anything on the stack. */
5807 parser_else (args)
5808      char *args;
5809 {
5810   register int i;
5811
5812   if (!if_stack_depth)
5813     {
5814       /* Error message? */
5815       return;
5816     }
5817
5818   /* Check the previous (n - 1) levels of the stack to make sure that
5819      we haven't previously turned off parsing. */
5820   for (i = 0; i < if_stack_depth - 1; i++)
5821     if (if_stack[i] == 1)
5822       return;
5823
5824   /* Invert the state of parsing if at top level. */
5825   parsing_conditionalized_out = !parsing_conditionalized_out;
5826 }
5827
5828 /* Terminate a conditional, popping the value of
5829    parsing_conditionalized_out from the stack. */
5830 parser_endif (args)
5831      char *args;
5832 {
5833   if (if_stack_depth)
5834     parsing_conditionalized_out = if_stack[--if_stack_depth];
5835   else
5836     {
5837       /* *** What, no error message? *** */
5838     }
5839 }
5840
5841 /* Associate textual names with actual functions. */
5842 static struct {
5843   char *name;
5844   Function *function;
5845 } parser_directives [] = {
5846   { "if", parser_if },
5847   { "endif", parser_endif },
5848   { "else", parser_else },
5849   { (char *)0x0, (Function *)0x0 }
5850 };
5851
5852 /* Handle a parser directive.  STATEMENT is the line of the directive
5853    without any leading `$'. */
5854 static int
5855 handle_parser_directive (statement)
5856      char *statement;
5857 {
5858   register int i;
5859   char *directive, *args;
5860
5861   /* Isolate the actual directive. */
5862
5863   /* Skip whitespace. */
5864   for (i = 0; whitespace (statement[i]); i++);
5865
5866   directive = &statement[i];
5867
5868   for (; statement[i] && !whitespace (statement[i]); i++);
5869
5870   if (statement[i])
5871     statement[i++] = '\0';
5872
5873   for (; statement[i] && whitespace (statement[i]); i++);
5874
5875   args = &statement[i];
5876
5877   /* Lookup the command, and act on it. */
5878   for (i = 0; parser_directives[i].name; i++)
5879     if (stricmp (directive, parser_directives[i].name) == 0)
5880       {
5881         (*parser_directives[i].function) (args);
5882         return (0);
5883       }
5884
5885   /* *** Should an error message be output? */
5886   return (1);
5887 }
5888
5889 /* Ugly but working hack for binding prefix meta. */
5890 #define PREFIX_META_HACK
5891
5892 static int substring_member_of_array ();
5893
5894 /* Read the binding command from STRING and perform it.
5895    A key binding command looks like: Keyname: function-name\0,
5896    a variable binding command looks like: set variable value.
5897    A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
5898 rl_parse_and_bind (string)
5899      char *string;
5900 {
5901   extern char *possible_control_prefixes[], *possible_meta_prefixes[];
5902   char *funname, *kname;
5903   register int c;
5904   int key, i;
5905
5906   while (string && whitespace (*string))
5907     string++;
5908
5909   if (!string || !*string || *string == '#')
5910     return;
5911
5912   /* If this is a parser directive, act on it. */
5913   if (*string == '$')
5914     {
5915       handle_parser_directive (&string[1]);
5916       return;
5917     }
5918
5919   /* If we are supposed to be skipping parsing right now, then do it. */
5920   if (parsing_conditionalized_out)
5921     return;
5922
5923   i = 0;
5924   /* If this keyname is a complex key expression surrounded by quotes,
5925      advance to after the matching close quote. */
5926   if (*string == '"')
5927     {
5928       for (i = 1; c = string[i]; i++)
5929         {
5930           if (c == '"' && string[i - 1] != '\\')
5931             break;
5932         }
5933     }
5934
5935   /* Advance to the colon (:) or whitespace which separates the two objects. */
5936   for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
5937
5938   /* Mark the end of the command (or keyname). */
5939   if (string[i])
5940     string[i++] = '\0';
5941
5942   /* If this is a command to set a variable, then do that. */
5943   if (stricmp (string, "set") == 0)
5944     {
5945       char *var = string + i;
5946       char *value;
5947
5948       /* Make VAR point to start of variable name. */
5949       while (*var && whitespace (*var)) var++;
5950
5951       /* Make value point to start of value string. */
5952       value = var;
5953       while (*value && !whitespace (*value)) value++;
5954       if (*value)
5955         *value++ = '\0';
5956       while (*value && whitespace (*value)) value++;
5957
5958       rl_variable_bind (var, value);
5959       return;
5960     }
5961
5962   /* Skip any whitespace between keyname and funname. */
5963   for (; string[i] && whitespace (string[i]); i++);
5964   funname = &string[i];
5965
5966   /* Now isolate funname.
5967      For straight function names just look for whitespace, since
5968      that will signify the end of the string.  But this could be a
5969      macro definition.  In that case, the string is quoted, so skip
5970      to the matching delimiter. */
5971   if (*funname == '\'' || *funname == '"')
5972     {
5973       int delimiter = string[i++];
5974
5975       for (; c = string[i]; i++)
5976         {
5977           if (c == delimiter && string[i - 1] != '\\')
5978             break;
5979         }
5980       if (c)
5981         i++;
5982     }
5983
5984   /* Advance to the end of the string.  */
5985   for (; string[i] && !whitespace (string[i]); i++);
5986
5987   /* No extra whitespace at the end of the string. */
5988   string[i] = '\0';
5989
5990   /* If this is a new-style key-binding, then do the binding with
5991      rl_set_key ().  Otherwise, let the older code deal with it. */
5992   if (*string == '"')
5993     {
5994       char *seq = (char *)alloca (1 + strlen (string));
5995       register int j, k = 0;
5996
5997       for (j = 1; string[j]; j++)
5998         {
5999           if (string[j] == '"' && string[j - 1] != '\\')
6000             break;
6001
6002           seq[k++] = string[j];
6003         }
6004       seq[k] = '\0';
6005
6006       /* Binding macro? */
6007       if (*funname == '\'' || *funname == '"')
6008         {
6009           j = strlen (funname);
6010
6011           if (j && funname[j - 1] == *funname)
6012             funname[j - 1] = '\0';
6013
6014           rl_macro_bind (seq, &funname[1], keymap);
6015         }
6016       else
6017         rl_set_key (seq, rl_named_function (funname), keymap);
6018
6019       return;
6020     }
6021
6022   /* Get the actual character we want to deal with. */
6023   kname = rindex (string, '-');
6024   if (!kname)
6025     kname = string;
6026   else
6027     kname++;
6028
6029   key = glean_key_from_name (kname);
6030
6031   /* Add in control and meta bits. */
6032   if (substring_member_of_array (string, possible_control_prefixes))
6033     key = CTRL (to_upper (key));
6034
6035   if (substring_member_of_array (string, possible_meta_prefixes))
6036     key = META (key);
6037
6038   /* Temporary.  Handle old-style keyname with macro-binding. */
6039   if (*funname == '\'' || *funname == '"')
6040     {
6041       char seq[2];
6042       int fl = strlen (funname);
6043
6044       seq[0] = key; seq[1] = '\0';
6045       if (fl && funname[fl - 1] == *funname)
6046         funname[fl - 1] = '\0';
6047
6048       rl_macro_bind (seq, &funname[1], keymap);
6049     }
6050 #if defined (PREFIX_META_HACK)
6051   /* Ugly, but working hack to keep prefix-meta around. */
6052   else if (stricmp (funname, "prefix-meta") == 0)
6053     {
6054       char seq[2];
6055
6056       seq[0] = key;
6057       seq[1] = '\0';
6058       rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, keymap);
6059     }
6060 #endif /* PREFIX_META_HACK */
6061   else
6062     rl_bind_key (key, rl_named_function (funname));
6063 }
6064
6065 rl_variable_bind (name, value)
6066      char *name, *value;
6067 {
6068   if (stricmp (name, "editing-mode") == 0)
6069     {
6070       if (strnicmp (value, "vi", 2) == 0)
6071         {
6072 #if defined (VI_MODE)
6073           keymap = vi_insertion_keymap;
6074           rl_editing_mode = vi_mode;
6075 #else
6076 #if defined (NOTDEF)
6077           /* What state is the terminal in?  I'll tell you:
6078              non-determinate!  That means we cannot do any output. */
6079           ding ();
6080 #endif /* NOTDEF */
6081 #endif /* VI_MODE */
6082         }
6083       else if (strnicmp (value, "emacs", 5) == 0)
6084         {
6085           keymap = emacs_standard_keymap;
6086           rl_editing_mode = emacs_mode;
6087         }
6088     }
6089   else if (stricmp (name, "horizontal-scroll-mode") == 0)
6090     {
6091       if (!*value || stricmp (value, "On") == 0)
6092         horizontal_scroll_mode = 1;
6093       else
6094         horizontal_scroll_mode = 0;
6095     }
6096   else if (stricmp (name, "mark-modified-lines") == 0)
6097     {
6098       if (!*value || stricmp (value, "On") == 0)
6099         mark_modified_lines = 1;
6100       else
6101         mark_modified_lines = 0;
6102     }
6103   else if (stricmp (name, "prefer-visible-bell") == 0)
6104     {
6105       if (!*value || stricmp (value, "On") == 0)
6106         prefer_visible_bell = 1;
6107       else
6108         prefer_visible_bell = 0;
6109     }
6110   else if (stricmp (name, "comment-begin") == 0)
6111     {
6112 #if defined (VI_MODE)
6113       extern char *rl_vi_comment_begin;
6114
6115       if (*value)
6116         {
6117           if (rl_vi_comment_begin)
6118             free (rl_vi_comment_begin);
6119
6120           rl_vi_comment_begin = savestring (value);
6121         }
6122 #endif /* VI_MODE */
6123     }
6124 }
6125
6126 /* Return the character which matches NAME.
6127    For example, `Space' returns ' '. */
6128
6129 typedef struct {
6130   char *name;
6131   int value;
6132 } assoc_list;
6133
6134 assoc_list name_key_alist[] = {
6135   { "DEL", 0x7f },
6136   { "ESC", '\033' },
6137   { "Escape", '\033' },
6138   { "LFD", '\n' },
6139   { "Newline", '\n' },
6140   { "RET", '\r' },
6141   { "Return", '\r' },
6142   { "Rubout", 0x7f },
6143   { "SPC", ' ' },
6144   { "Space", ' ' },
6145   { "Tab", 0x09 },
6146   { (char *)0x0, 0 }
6147 };
6148
6149 int
6150 glean_key_from_name (name)
6151      char *name;
6152 {
6153   register int i;
6154
6155   for (i = 0; name_key_alist[i].name; i++)
6156     if (stricmp (name, name_key_alist[i].name) == 0)
6157       return (name_key_alist[i].value);
6158
6159   return (*name);
6160 }
6161
6162 \f
6163 /* **************************************************************** */
6164 /*                                                                  */
6165 /*                Key Binding and Function Information              */
6166 /*                                                                  */
6167 /* **************************************************************** */
6168
6169 /* Each of the following functions produces information about the
6170    state of keybindings and functions known to Readline.  The info
6171    is always printed to rl_outstream, and in such a way that it can
6172    be read back in (i.e., passed to rl_parse_and_bind (). */
6173
6174 /* Print the names of functions known to Readline. */
6175 void
6176 rl_list_funmap_names (ignore)
6177      int ignore;
6178 {
6179   register int i;
6180   char **funmap_names;
6181   extern char **rl_funmap_names ();
6182
6183   funmap_names = rl_funmap_names ();
6184
6185   if (!funmap_names)
6186     return;
6187
6188   for (i = 0; funmap_names[i]; i++)
6189     fprintf (rl_outstream, "%s\n", funmap_names[i]);
6190
6191   free (funmap_names);
6192 }
6193
6194 /* Return a NULL terminated array of strings which represent the key
6195    sequences that are used to invoke FUNCTION in MAP. */
6196 static char **
6197 invoking_keyseqs_in_map (function, map)
6198      Function *function;
6199      Keymap map;
6200 {
6201   register int key;
6202   char **result;
6203   int result_index, result_size;
6204
6205   result = (char **)NULL;
6206   result_index = result_size = 0;
6207
6208   for (key = 0; key < 128; key++)
6209     {
6210       switch (map[key].type)
6211         {
6212         case ISMACR:
6213           /* Macros match, if, and only if, the pointers are identical.
6214              Thus, they are treated exactly like functions in here. */
6215         case ISFUNC:
6216           /* If the function in the keymap is the one we are looking for,
6217              then add the current KEY to the list of invoking keys. */
6218           if (map[key].function == function)
6219             {
6220               char *keyname = (char *)xmalloc (5);
6221
6222               if (CTRL_P (key))
6223                 sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key)));
6224               else if (key == RUBOUT)
6225                 sprintf (keyname, "\\C-?");
6226               else
6227                 sprintf (keyname, "%c", key);
6228
6229               if (result_index + 2 > result_size)
6230                 {
6231                   if (!result)
6232                     result = (char **) xmalloc
6233                       ((result_size = 10) * sizeof (char *));
6234                   else
6235                     result = (char **) xrealloc
6236                       (result, (result_size += 10) * sizeof (char *));
6237                 }
6238
6239               result[result_index++] = keyname;
6240               result[result_index] = (char *)NULL;
6241             }
6242           break;
6243
6244         case ISKMAP:
6245           {
6246             char **seqs = (char **)NULL;
6247
6248             /* Find the list of keyseqs in this map which have FUNCTION as
6249                their target.  Add the key sequences found to RESULT. */
6250             if (map[key].function)
6251               seqs =
6252                 invoking_keyseqs_in_map (function, (Keymap)map[key].function);
6253
6254             if (seqs)
6255               {
6256                 register int i;
6257
6258                 for (i = 0; seqs[i]; i++)
6259                   {
6260                     char *keyname = (char *)xmalloc (6 + strlen (seqs[i]));
6261
6262                     if (key == ESC)
6263                       sprintf (keyname, "\\e");
6264                     else if (CTRL_P (key))
6265                       sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key)));
6266                     else if (key == RUBOUT)
6267                       sprintf (keyname, "\\C-?");
6268                     else
6269                       sprintf (keyname, "%c", key);
6270
6271                     strcat (keyname, seqs[i]);
6272
6273                     if (result_index + 2 > result_size)
6274                       {
6275                         if (!result)
6276                           result = (char **)
6277                             xmalloc ((result_size = 10) * sizeof (char *));
6278                         else
6279                           result = (char **)
6280                             xrealloc (result,
6281                                       (result_size += 10) * sizeof (char *));
6282                       }
6283
6284                     result[result_index++] = keyname;
6285                     result[result_index] = (char *)NULL;
6286                   }
6287               }
6288           }
6289           break;
6290         }
6291     }
6292   return (result);
6293 }
6294
6295 /* Return a NULL terminated array of strings which represent the key
6296    sequences that can be used to invoke FUNCTION using the current keymap. */
6297 char **
6298 rl_invoking_keyseqs (function)
6299      Function *function;
6300 {
6301   return (invoking_keyseqs_in_map (function, keymap));
6302 }
6303
6304 /* Print all of the current functions and their bindings to
6305    rl_outstream.  If an explicit argument is given, then print
6306    the output in such a way that it can be read back in. */
6307 int
6308 rl_dump_functions (count)
6309      int count;
6310 {
6311   void rl_function_dumper ();
6312
6313   rl_function_dumper (rl_explicit_arg);
6314   rl_on_new_line ();
6315   return (0);
6316 }
6317
6318 /* Print all of the functions and their bindings to rl_outstream.  If
6319    PRINT_READABLY is non-zero, then print the output in such a way
6320    that it can be read back in. */
6321 void
6322 rl_function_dumper (print_readably)
6323      int print_readably;
6324 {
6325   register int i;
6326   char **rl_funmap_names (), **names;
6327   char *name;
6328
6329   names = rl_funmap_names ();
6330
6331   fprintf (rl_outstream, "\n");
6332
6333   for (i = 0; name = names[i]; i++)
6334     {
6335       Function *function;
6336       char **invokers;
6337
6338       function = rl_named_function (name);
6339       invokers = invoking_keyseqs_in_map (function, keymap);
6340
6341       if (print_readably)
6342         {
6343           if (!invokers)
6344             fprintf (rl_outstream, "# %s (not bound)\n", name);
6345           else
6346             {
6347               register int j;
6348
6349               for (j = 0; invokers[j]; j++)
6350                 {
6351                   fprintf (rl_outstream, "\"%s\": %s\n",
6352                            invokers[j], name);
6353                   free (invokers[j]);
6354                 }
6355
6356               free (invokers);
6357             }
6358         }
6359       else
6360         {
6361           if (!invokers)
6362             fprintf (rl_outstream, "%s is not bound to any keys\n",
6363                      name);
6364           else
6365             {
6366               register int j;
6367
6368               fprintf (rl_outstream, "%s can be found on ", name);
6369
6370               for (j = 0; invokers[j] && j < 5; j++)
6371                 {
6372                   fprintf (rl_outstream, "\"%s\"%s", invokers[j],
6373                            invokers[j + 1] ? ", " : ".\n");
6374                 }
6375
6376               if (j == 5 && invokers[j])
6377                 fprintf (rl_outstream, "...\n");
6378
6379               for (j = 0; invokers[j]; j++)
6380                 free (invokers[j]);
6381
6382               free (invokers);
6383             }
6384         }
6385     }
6386 }
6387
6388 \f
6389 /* **************************************************************** */
6390 /*                                                                  */
6391 /*                      String Utility Functions                    */
6392 /*                                                                  */
6393 /* **************************************************************** */
6394
6395 static char *strindex ();
6396
6397 /* Return pointer to first occurance in STRING1 of any character from STRING2,
6398    or NULL if no occurance found. */
6399 static char *
6400 strpbrk (string1, string2)
6401      char *string1, *string2;
6402 {
6403   register char *scan;
6404
6405   for (; *string1 != '\0'; string1++)
6406     {
6407       for (scan = string2; *scan != '\0'; scan++)
6408         {
6409           if (*string1 == *scan)
6410             {
6411               return (string1);
6412             }
6413         }
6414     }
6415   return (NULL);
6416 }
6417
6418 /* Return non-zero if any members of ARRAY are a substring in STRING. */
6419 static int
6420 substring_member_of_array (string, array)
6421      char *string, **array;
6422 {
6423   while (*array)
6424     {
6425       if (strindex (string, *array))
6426         return (1);
6427       array++;
6428     }
6429   return (0);
6430 }
6431
6432 /* Whoops, Unix doesn't have strnicmp. */
6433
6434 /* Compare at most COUNT characters from string1 to string2.  Case
6435    doesn't matter. */
6436 static int
6437 strnicmp (string1, string2, count)
6438      char *string1, *string2;
6439 {
6440   register char ch1, ch2;
6441
6442   while (count)
6443     {
6444       ch1 = *string1++;
6445       ch2 = *string2++;
6446       if (to_upper(ch1) == to_upper(ch2))
6447         count--;
6448       else break;
6449     }
6450   return (count);
6451 }
6452
6453 /* strcmp (), but caseless. */
6454 static int
6455 stricmp (string1, string2)
6456      char *string1, *string2;
6457 {
6458   register char ch1, ch2;
6459
6460   while (*string1 && *string2)
6461     {
6462       ch1 = *string1++;
6463       ch2 = *string2++;
6464       if (to_upper(ch1) != to_upper(ch2))
6465         return (1);
6466     }
6467   return (*string1 | *string2);
6468 }
6469
6470 /* Determine if s2 occurs in s1.  If so, return a pointer to the
6471    match in s1.  The compare is case insensitive. */
6472 static char *
6473 strindex (s1, s2)
6474      register char *s1, *s2;
6475 {
6476   register int i, l = strlen (s2);
6477   register int len = strlen (s1);
6478
6479   for (i = 0; (len - i) >= l; i++)
6480     if (strnicmp (&s1[i], s2, l) == 0)
6481       return (s1 + i);
6482   return ((char *)NULL);
6483 }
6484
6485 \f
6486 /* **************************************************************** */
6487 /*                                                                  */
6488 /*                      USG (System V) Support                      */
6489 /*                                                                  */
6490 /* **************************************************************** */
6491
6492 /* When compiling and running in the `Posix' environment, Ultrix does
6493    not restart system calls, so this needs to do it. */
6494 int
6495 rl_getc (stream)
6496      FILE *stream;
6497 {
6498   int result;
6499   unsigned char c;
6500
6501 #ifdef __GO32__
6502   if (isatty(0))
6503     return getkey();
6504 #endif /* __GO32__ */
6505
6506   while (1)
6507     {
6508       result = read (fileno (stream), &c, sizeof (char));
6509
6510       if (result == sizeof (char))
6511         return (c);
6512
6513       /* If zero characters are returned, then the file that we are
6514          reading from is empty!  Return EOF in that case. */
6515       if (result == 0)
6516         return (EOF);
6517
6518 #ifndef __GO32__
6519       /* If the error that we received was SIGINT, then try again,
6520          this is simply an interrupted system call to read ().
6521          Otherwise, some error ocurred, also signifying EOF. */
6522       if (errno != EINTR)
6523         return (EOF);
6524 #endif /* !__GO32__ */
6525     }
6526 }
6527
6528 #if defined (STATIC_MALLOC)
6529 \f
6530 /* **************************************************************** */
6531 /*                                                                  */
6532 /*                      xmalloc and xrealloc ()                     */
6533 /*                                                                  */
6534 /* **************************************************************** */
6535
6536 static void memory_error_and_abort ();
6537
6538 static char *
6539 xmalloc (bytes)
6540      int bytes;
6541 {
6542   char *temp = (char *)malloc (bytes);
6543
6544   if (!temp)
6545     memory_error_and_abort ();
6546   return (temp);
6547 }
6548
6549 static char *
6550 xrealloc (pointer, bytes)
6551      char *pointer;
6552      int bytes;
6553 {
6554   char *temp;
6555
6556   if (!pointer)
6557     temp = (char *)malloc (bytes);
6558   else
6559     temp = (char *)realloc (pointer, bytes);
6560
6561   if (!temp)
6562     memory_error_and_abort ();
6563
6564   return (temp);
6565 }
6566
6567 static void
6568 memory_error_and_abort ()
6569 {
6570   fprintf (stderr, "readline: Out of virtual memory!\n");
6571   abort ();
6572 }
6573 #endif /* STATIC_MALLOC */
6574
6575 \f
6576 /* **************************************************************** */
6577 /*                                                                  */
6578 /*                      Testing Readline                            */
6579 /*                                                                  */
6580 /* **************************************************************** */
6581
6582 #if defined (TEST)
6583
6584 main ()
6585 {
6586   HIST_ENTRY **history_list ();
6587   char *temp = (char *)NULL;
6588   char *prompt = "readline% ";
6589   int done = 0;
6590
6591   while (!done)
6592     {
6593       temp = readline (prompt);
6594
6595       /* Test for EOF. */
6596       if (!temp)
6597         exit (1);
6598
6599       /* If there is anything on the line, print it and remember it. */
6600       if (*temp)
6601         {
6602           fprintf (stderr, "%s\r\n", temp);
6603           add_history (temp);
6604         }
6605
6606       /* Check for `command' that we handle. */
6607       if (strcmp (temp, "quit") == 0)
6608         done = 1;
6609
6610       if (strcmp (temp, "list") == 0)
6611         {
6612           HIST_ENTRY **list = history_list ();
6613           register int i;
6614           if (list)
6615             {
6616               for (i = 0; list[i]; i++)
6617                 {
6618                   fprintf (stderr, "%d: %s\r\n", i, list[i]->line);
6619                   free (list[i]->line);
6620                 }
6621               free (list);
6622             }
6623         }
6624       free (temp);
6625     }
6626 }
6627
6628 #endif /* TEST */
6629
6630 \f
6631 /*
6632  * Local variables:
6633  * compile-command: "gcc -g -traditional -I. -I.. -DTEST -o readline readline.c keymaps.o funmap.o history.o -ltermcap"
6634  * end:
6635  */