Subversion Repositories or1k

/* readline.c -- a general facility for reading lines of input

   with emacs style editing and completion. */

/* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for

   reading lines of text with interactive input and history editing.

   The GNU Readline Library is free software; you can redistribute it

   and/or modify it under the terms of the GNU General Public License

   as published by the Free Software Foundation; either version 1, or

   (at your option) any later version.

   The GNU Readline Library is distributed in the hope that it will be

   useful, but WITHOUT ANY WARRANTY; without even the implied warranty

   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   The GNU General Public License is often shipped with GNU software, and

   is generally kept in a file called COPYING or LICENSE.  If you do not

   have a copy of the license, write to the Free Software Foundation,

   675 Mass Ave, Cambridge, MA 02139, USA. */

#define READLINE_LIBRARY

#if defined (HAVE_CONFIG_H)

#  include <config.h>

#endif

#include <sys/types.h>

#include "posixstat.h"

#include <fcntl.h>

#if defined (HAVE_SYS_FILE_H)

#  include <sys/file.h>

#endif /* HAVE_SYS_FILE_H */

#if defined (HAVE_UNISTD_H)

#  include <unistd.h>

#endif /* HAVE_UNISTD_H */

#if defined (HAVE_STDLIB_H)

#  include <stdlib.h>

#else

#  include "ansi_stdlib.h"

#endif /* HAVE_STDLIB_H */

#if defined (HAVE_LOCALE_H)

#  include <locale.h>

#endif

#include <signal.h>

#include <stdio.h>

#include "posixjmp.h"

/* System-specific feature definitions and include files. */

#include "rldefs.h"

#if defined (__EMX__)

#  define INCL_DOSPROCESS

#  include <os2.h>

#endif /* __EMX__ */

/* Some standard library routines. */

#include "readline.h"

#include "history.h"

#ifndef RL_LIBRARY_VERSION

#  define RL_LIBRARY_VERSION "4.0"

#endif

/* Evaluates its arguments multiple times. */

#define SWAP(s, e)  do { int t; t = s; s = e; e = t; } while (0)

/* NOTE: Functions and variables prefixed with `_rl_' are

   pseudo-global: they are global so they can be shared

   between files in the readline library, but are not intended

   to be visible to readline callers. */

/* Variables and functions imported from terminal.c */

extern int _rl_init_terminal_io ();

extern void _rl_enable_meta_key ();

#ifdef _MINIX

extern void _rl_output_character_function ();

#else

extern int _rl_output_character_function ();

#endif

extern int _rl_enable_meta;

extern int _rl_term_autowrap;

extern int screenwidth, screenheight, screenchars;

/* Variables and functions imported from rltty.c. */

extern void rl_prep_terminal (), rl_deprep_terminal ();

extern void rltty_set_default_bindings ();

/* Functions imported from util.c. */

extern void _rl_abort_internal ();

extern void rl_extend_line_buffer ();

extern int alphabetic ();

/* Functions imported from bind.c. */

extern void _rl_bind_if_unbound ();

/* Functions imported from input.c. */

extern int _rl_any_typein ();

extern void _rl_insert_typein ();

extern int rl_read_key ();

/* Functions imported from nls.c */

extern int _rl_init_eightbit ();

/* Functions imported from shell.c */

extern char *get_env_value ();

/* External redisplay functions and variables from display.c */

extern void _rl_move_vert ();

extern void _rl_update_final ();

extern void _rl_clear_to_eol ();

extern void _rl_clear_screen ();

extern void _rl_erase_entire_line ();

extern void _rl_erase_at_end_of_line ();

extern void _rl_move_cursor_relative ();

extern int _rl_vis_botlin;

extern int _rl_last_c_pos;

extern int _rl_horizontal_scroll_mode;

extern int rl_display_fixed;

extern int _rl_suppress_redisplay;

extern char *rl_display_prompt;

/* Variables imported from complete.c. */

extern char *rl_completer_word_break_characters;

extern char *rl_basic_word_break_characters;

extern int rl_completion_query_items;

extern int rl_complete_with_tilde_expansion;

/* Variables and functions from macro.c. */

extern void _rl_add_macro_char ();

extern void _rl_with_macro_input ();

extern int _rl_next_macro_key ();

extern int _rl_defining_kbd_macro;

#if defined (VI_MODE)

/* Functions imported from vi_mode.c. */

extern void _rl_vi_set_last ();

extern void _rl_vi_reset_last ();

extern void _rl_vi_done_inserting ();

extern int _rl_vi_textmod_command ();

extern void _rl_vi_initialize_line ();

#endif /* VI_MODE */

extern UNDO_LIST *rl_undo_list;

extern int _rl_doing_an_undo;

/* Forward declarations used in this file. */

void _rl_free_history_entry ();

int _rl_dispatch ();

int _rl_init_argument ();

static char *readline_internal ();

static void readline_initialize_everything ();

static void start_using_history ();

static void bind_arrow_keys ();

#if !defined (__GO32__) || defined (HAVE_TERMIOS_H)

static void readline_default_bindings ();

#endif /* !__GO32__ */

#if defined (__GO32__)

#  include <go32.h>

#  include <pc.h>

#  if !defined (__DJGPP__)

#    undef HANDLE_SIGNALS

#  endif /* !__DJGPP__ */

#endif /* __GO32__ */

extern char *xmalloc (), *xrealloc ();

/* **************************************************************** */

/*                                                                  */

/*                      Line editing input utility                  */

/*                                                                  */

/* **************************************************************** */

char *rl_library_version = RL_LIBRARY_VERSION;

/* A pointer to the keymap that is currently in use.

   By default, it is the standard emacs keymap. */

Keymap _rl_keymap = emacs_standard_keymap;

/* The current style of editing. */

int rl_editing_mode = emacs_mode;

/* Non-zero if we called this function from _rl_dispatch().  It's present

   so functions can find out whether they were called from a key binding

   or directly from an application. */

int rl_dispatching;

/* Non-zero if the previous command was a kill command. */

int _rl_last_command_was_kill = 0;

/* The current value of the numeric argument specified by the user. */

int rl_numeric_arg = 1;

/* Non-zero if an argument was typed. */

int rl_explicit_arg = 0;

/* Temporary value used while generating the argument. */

int rl_arg_sign = 1;

/* Non-zero means we have been called at least once before. */

static int rl_initialized;

/* If non-zero, this program is running in an EMACS buffer. */

static int running_in_emacs;

/* The current offset in the current input line. */

int rl_point;

/* Mark in the current input line. */

int rl_mark;

/* Length of the current input line. */

int rl_end;

/* Make this non-zero to return the current input_line. */

int rl_done;

/* The last function executed by readline. */

Function *rl_last_func = (Function *)NULL;

/* Top level environment for readline_internal (). */

procenv_t readline_top_level;

/* The streams we interact with. */

FILE *_rl_in_stream, *_rl_out_stream;

/* The names of the streams that we do input and output to. */

FILE *rl_instream = (FILE *)NULL;

FILE *rl_outstream = (FILE *)NULL;

/* Non-zero means echo characters as they are read. */

int readline_echoing_p = 1;

/* Current prompt. */

char *rl_prompt;

int rl_visible_prompt_length = 0;

/* The number of characters read in order to type this complete command. */

int rl_key_sequence_length = 0;

/* If non-zero, then this is the address of a function to call just

   before readline_internal_setup () prints the first prompt. */

Function *rl_startup_hook = (Function *)NULL;

/* If non-zero, this is the address of a function to call just before

   readline_internal_setup () returns and readline_internal starts

   reading input characters. */

Function *rl_pre_input_hook = (Function *)NULL;

/* What we use internally.  You should always refer to RL_LINE_BUFFER. */

static char *the_line;

/* The character that can generate an EOF.  Really read from

   the terminal driver... just defaulted here. */

int _rl_eof_char = CTRL ('D');

/* Non-zero makes this the next keystroke to read. */

int rl_pending_input = 0;

/* Pointer to a useful terminal name. */

char *rl_terminal_name = (char *)NULL;

/* Non-zero means to always use horizontal scrolling in line display. */

int _rl_horizontal_scroll_mode = 0;

/* Non-zero means to display an asterisk at the starts of history lines

   which have been modified. */

int _rl_mark_modified_lines = 0;

/* The style of `bell' notification preferred.  This can be set to NO_BELL,

   AUDIBLE_BELL, or VISIBLE_BELL. */

int _rl_bell_preference = AUDIBLE_BELL;

/* String inserted into the line by rl_insert_comment (). */

char *_rl_comment_begin;

/* Keymap holding the function currently being executed. */

Keymap rl_executing_keymap;

/* Non-zero means to erase entire line, including prompt, on empty input lines. */

int rl_erase_empty_line = 0;

/* Line buffer and maintenence. */

char *rl_line_buffer = (char *)NULL;

int rl_line_buffer_len = 0;

/* Forward declarations used by the display and termcap code. */

/* **************************************************************** */

/*                                                                  */

/*                      `Forward' declarations                      */

/*                                                                  */

/* **************************************************************** */

/* Non-zero means do not parse any lines other than comments and

   parser directives. */

unsigned char _rl_parsing_conditionalized_out = 0;

/* Non-zero means to convert characters with the meta bit set to

   escape-prefixed characters so we can indirect through

   emacs_meta_keymap or vi_escape_keymap. */

int _rl_convert_meta_chars_to_ascii = 1;

/* Non-zero means to output characters with the meta bit set directly

   rather than as a meta-prefixed escape sequence. */

int _rl_output_meta_chars = 0;

/* **************************************************************** */

/*                                                                  */

/*                      Top Level Functions                         */

/*                                                                  */

/* **************************************************************** */

/* Non-zero means treat 0200 bit in terminal input as Meta bit. */

int _rl_meta_flag = 0;   /* Forward declaration */

/* Read a line of input.  Prompt with PROMPT.  An empty PROMPT means

   none.  A return value of NULL means that EOF was encountered. */

char *

readline (prompt)

     char *prompt;

{

  char *value;

  rl_prompt = prompt;

  /* If we are at EOF return a NULL string. */

  if (rl_pending_input == EOF)

    {

      rl_pending_input = 0;

      return ((char *)NULL);

    }

  rl_visible_prompt_length = rl_expand_prompt (rl_prompt);

  rl_initialize ();

  (*rl_prep_term_function) (_rl_meta_flag);

#if defined (HANDLE_SIGNALS)

  rl_set_signals ();

#endif

  value = readline_internal ();

  (*rl_deprep_term_function) ();

#if defined (HANDLE_SIGNALS)

  rl_clear_signals ();

#endif

  return (value);

}

#if defined (READLINE_CALLBACKS)

#  define STATIC_CALLBACK

#else

#  define STATIC_CALLBACK static

#endif

STATIC_CALLBACK void

readline_internal_setup ()

{

  _rl_in_stream = rl_instream;

  _rl_out_stream = rl_outstream;

  if (rl_startup_hook)

    (*rl_startup_hook) ();

  if (readline_echoing_p == 0)

    {

      if (rl_prompt)

        {

          fprintf (_rl_out_stream, "%s", rl_prompt);

          fflush (_rl_out_stream);

        }

    }

  else

    {

      rl_on_new_line ();

      (*rl_redisplay_function) ();

#if defined (VI_MODE)

      if (rl_editing_mode == vi_mode)

        rl_vi_insertion_mode (1, 0);

#endif /* VI_MODE */

    }

  if (rl_pre_input_hook)

    (*rl_pre_input_hook) ();

}

STATIC_CALLBACK char *

readline_internal_teardown (eof)

     int eof;

{

  char *temp;

  HIST_ENTRY *entry;

  /* Restore the original of this history line, iff the line that we

     are editing was originally in the history, AND the line has changed. */

  entry = current_history ();

  if (entry && rl_undo_list)

    {

      temp = savestring (the_line);

      rl_revert_line (1, 0);

      entry = replace_history_entry (where_history (), the_line, (histdata_t)NULL);

      _rl_free_history_entry (entry);

      strcpy (the_line, temp);

      free (temp);

    }

  /* At any rate, it is highly likely that this line has an undo list.  Get

     rid of it now. */

  if (rl_undo_list)

    free_undo_list ();

  return (eof ? (char *)NULL : savestring (the_line));

}

STATIC_CALLBACK int

#if defined (READLINE_CALLBACKS)

readline_internal_char ()

#else

readline_internal_charloop ()

#endif

{

  static int lastc, eof_found;

  int c, code, lk;

  lastc = -1;

  eof_found = 0;

#if !defined (READLINE_CALLBACKS)

  while (rl_done == 0)

    {

#endif

      lk = _rl_last_command_was_kill;

      code = setjmp (readline_top_level);

      if (code)

        (*rl_redisplay_function) ();

      if (rl_pending_input == 0)

        {

          /* Then initialize the argument and number of keys read. */

          _rl_init_argument ();

          rl_key_sequence_length = 0;

        }

      c = rl_read_key ();

      /* EOF typed to a non-blank line is a <NL>. */

      if (c == EOF && rl_end)

        c = NEWLINE;

      /* The character _rl_eof_char typed to blank line, and not as the

         previous character is interpreted as EOF. */

      if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end)

        {

#if defined (READLINE_CALLBACKS)

          return (rl_done = 1);

#else

          eof_found = 1;

          break;

#endif

        }

      lastc = c;

      _rl_dispatch (c, _rl_keymap);

      /* If there was no change in _rl_last_command_was_kill, then no kill

         has taken place.  Note that if input is pending we are reading

         a prefix command, so nothing has changed yet. */

      if (rl_pending_input == 0 && lk == _rl_last_command_was_kill)

        _rl_last_command_was_kill = 0;

#if defined (VI_MODE)

      /* In vi mode, when you exit insert mode, the cursor moves back

         over the previous character.  We explicitly check for that here. */

      if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap)

        rl_vi_check ();

#endif /* VI_MODE */

      if (rl_done == 0)

        (*rl_redisplay_function) ();

      /* If the application writer has told us to erase the entire line if

          the only character typed was something bound to rl_newline, do so. */

      if (rl_erase_empty_line && rl_done && rl_last_func == rl_newline &&

          rl_point == 0 && rl_end == 0)

        _rl_erase_entire_line ();

#if defined (READLINE_CALLBACKS)

      return 0;

#else

    }

  return (eof_found);

#endif

}

#if defined (READLINE_CALLBACKS)

static int

readline_internal_charloop ()

{

  int eof = 1;

  while (rl_done == 0)

    eof = readline_internal_char ();

  return (eof);

}

#endif /* READLINE_CALLBACKS */

/* Read a line of input from the global rl_instream, doing output on

   the global rl_outstream.

   If rl_prompt is non-null, then that is our prompt. */

static char *

readline_internal ()

{

  int eof;

  readline_internal_setup ();

  eof = readline_internal_charloop ();

  return (readline_internal_teardown (eof));

}

void

_rl_init_line_state ()

{

  rl_point = rl_end = 0;

  the_line = rl_line_buffer;

  the_line[0] = 0;

}

void

_rl_set_the_line ()

{

  the_line = rl_line_buffer;

}

/* Do the command associated with KEY in MAP.

   If the associated command is really a keymap, then read

   another key, and dispatch into that map. */

int

_rl_dispatch (key, map)

     register int key;

     Keymap map;

{

  int r, newkey;

  char *macro;

  Function *func;

  if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii)

    {

      if (map[ESC].type == ISKMAP)

        {

          if (_rl_defining_kbd_macro)

            _rl_add_macro_char (ESC);

          map = FUNCTION_TO_KEYMAP (map, ESC);

          key = UNMETA (key);

          rl_key_sequence_length += 2;

          return (_rl_dispatch (key, map));

        }

      else

        ding ();

      return 0;

    }

  if (_rl_defining_kbd_macro)

    _rl_add_macro_char (key);

  r = 0;

  switch (map[key].type)

    {

    case ISFUNC:

      func = map[key].function;

      if (func != (Function *)NULL)

        {

          /* Special case rl_do_lowercase_version (). */

          if (func == rl_do_lowercase_version)

            return (_rl_dispatch (_rl_to_lower (key), map));

          rl_executing_keymap = map;

#if 0

          _rl_suppress_redisplay = (map[key].function == rl_insert) && _rl_input_available ();

#endif

          rl_dispatching = 1;

          r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key);

          rl_dispatching = 0;

          /* If we have input pending, then the last command was a prefix

             command.  Don't change the state of rl_last_func.  Otherwise,

             remember the last command executed in this variable. */

          if (!rl_pending_input && map[key].function != rl_digit_argument)

            rl_last_func = map[key].function;

        }

      else

        {

          _rl_abort_internal ();

          return -1;

        }

      break;

    case ISKMAP:

      if (map[key].function != (Function *)NULL)

        {

          rl_key_sequence_length++;

          newkey = rl_read_key ();

          r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key));

        }

      else

        {

          _rl_abort_internal ();

          return -1;

        }

      break;

    case ISMACR:

      if (map[key].function != (Function *)NULL)

        {

          macro = savestring ((char *)map[key].function);

          _rl_with_macro_input (macro);

          return 0;

        }

      break;

    }

#if defined (VI_MODE)

  if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap &&

      _rl_vi_textmod_command (key))

    _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign);

#endif

  return (r);

}

/* **************************************************************** */

/*                                                                  */

/*                      Initializations                             */

/*                                                                  */

/* **************************************************************** */

/* Initialize readline (and terminal if not already). */

int

rl_initialize ()

{

  /* If we have never been called before, initialize the

     terminal and data structures. */

  if (!rl_initialized)

    {

      readline_initialize_everything ();

      rl_initialized++;

    }

  /* Initalize the current line information. */

  _rl_init_line_state ();

  /* We aren't done yet.  We haven't even gotten started yet! */

  rl_done = 0;

  /* Tell the history routines what is going on. */

  start_using_history ();

  /* Make the display buffer match the state of the line. */

  rl_reset_line_state ();

  /* No such function typed yet. */

  rl_last_func = (Function *)NULL;

  /* Parsing of key-bindings begins in an enabled state. */

  _rl_parsing_conditionalized_out = 0;

#if defined (VI_MODE)

  if (rl_editing_mode == vi_mode)

    _rl_vi_initialize_line ();

#endif

  return 0;

}

#if defined (__EMX__)

static void

_emx_build_environ ()

{

  TIB *tibp;

  PIB *pibp;

  char *t, **tp;

  int c;

  DosGetInfoBlocks (&tibp, &pibp);

  t = pibp->pib_pchenv;

  for (c = 1; *t; c++)

    t += strlen (t) + 1;

  tp = environ = (char **)xmalloc ((c + 1) * sizeof (char *));

  t = pibp->pib_pchenv;

  while (*t)

    {

      *tp++ = t;

      t += strlen (t) + 1;

    }

  *tp = 0;

}

#endif /* __EMX__ */

/* Initialize the entire state of the world. */

static void

readline_initialize_everything ()

{

#if defined (__EMX__)

  if (environ == 0)

    _emx_build_environ ();

#endif

  /* Find out if we are running in Emacs. */

  running_in_emacs = get_env_value ("EMACS") != (char *)0;

  /* Set up input and output if they are not already set up. */