contrib/gdb-7/readline/callback.c

   1 /* callback.c -- functions to use readline as an X `callback' mechanism. */
   2
   3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library (Readline), a library
   6    for reading lines of text with interactive input and history editing.
   7
   8    Readline is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    Readline is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include "rlconf.h"
  29
  30 #if defined (READLINE_CALLBACKS)
  31
  32 #include <sys/types.h>
  33
  34 #ifdef HAVE_STDLIB_H
  35 #  include <stdlib.h>
  36 #else
  37 #  include "ansi_stdlib.h"
  38 #endif
  39
  40 #include <stdio.h>
  41
  42 /* System-specific feature definitions and include files. */
  43 #include "rldefs.h"
  44 #include "readline.h"
  45 #include "rlprivate.h"
  46 #include "xmalloc.h"
  47
  48 /* Private data for callback registration functions.  See comments in
  49    rl_callback_read_char for more details. */
  50 _rl_callback_func_t *_rl_callback_func = 0;
  51 _rl_callback_generic_arg *_rl_callback_data = 0;
  52
  53 /* **************************************************************** */
  54 /*                                                                  */
  55 /*                      Callback Readline Functions              */
  56 /*                                                                  */
  57 /* **************************************************************** */
  58
  59 /* Allow using readline in situations where a program may have multiple
  60    things to handle at once, and dispatches them via select().  Call
  61    rl_callback_handler_install() with the prompt and a function to call
  62    whenever a complete line of input is ready.  The user must then
  63    call rl_callback_read_char() every time some input is available, and
  64    rl_callback_read_char() will call the user's function with the complete
  65    text read in at each end of line.  The terminal is kept prepped and
  66    signals handled all the time, except during calls to the user's function. */
  67
  68 rl_vcpfunc_t *rl_linefunc;              /* user callback function */
  69 static int in_handler;          /* terminal_prepped and signals set? */
  70
  71 /* Make sure the terminal is set up, initialize readline, and prompt. */
  72 static void
  73 _rl_callback_newline ()
  74 {
  75   rl_initialize ();
  76
  77   if (in_handler == 0)
  78     {
  79       in_handler = 1;
  80
  81       if (rl_prep_term_function)
  82         (*rl_prep_term_function) (_rl_meta_flag);
  83
  84 #if defined (HANDLE_SIGNALS)
  85       rl_set_signals ();
  86 #endif
  87     }
  88
  89   readline_internal_setup ();
  90   RL_CHECK_SIGNALS ();
  91 }
  92
  93 /* Install a readline handler, set up the terminal, and issue the prompt. */
  94 void
  95 rl_callback_handler_install (prompt, linefunc)
  96      const char *prompt;
  97      rl_vcpfunc_t *linefunc;
  98 {
  99   rl_set_prompt (prompt);
 100   RL_SETSTATE (RL_STATE_CALLBACK);
 101   rl_linefunc = linefunc;
 102   _rl_callback_newline ();
 103 }
 104
 105 /* Read one character, and dispatch to the handler if it ends the line. */
 106 void
 107 rl_callback_read_char ()
 108 {
 109   char *line;
 110   int eof, jcode;
 111   static procenv_t olevel;
 112
 113   if (rl_linefunc == NULL)
 114     {
 115       _rl_errmsg ("readline_callback_read_char() called with no handler!");
 116       abort ();
 117     }
 118
 119   memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t));
 120   jcode = setjmp (_rl_top_level);
 121   if (jcode)
 122     {
 123       (*rl_redisplay_function) ();
 124       _rl_want_redisplay = 0;
 125       memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t));
 126       return;
 127     }
 128
 129   do
 130     {
 131       RL_CHECK_SIGNALS ();
 132       if  (RL_ISSTATE (RL_STATE_ISEARCH))
 133         {
 134           eof = _rl_isearch_callback (_rl_iscxt);
 135           if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 136             rl_callback_read_char ();
 137
 138           return;
 139         }
 140       else if  (RL_ISSTATE (RL_STATE_NSEARCH))
 141         {
 142           eof = _rl_nsearch_callback (_rl_nscxt);
 143           return;
 144         }
 145 #if defined (VI_MODE)
 146       else if (RL_ISSTATE (RL_STATE_VIMOTION))
 147         {
 148           eof = _rl_vi_domove_callback (_rl_vimvcxt);
 149           /* Should handle everything, including cleanup, numeric arguments,
 150              and turning off RL_STATE_VIMOTION */
 151           if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 152             _rl_internal_char_cleanup ();
 153
 154           return;
 155         }
 156 #endif
 157       else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 158         {
 159           eof = _rl_arg_callback (_rl_argcxt);
 160           if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 161             rl_callback_read_char ();
 162           /* XXX - this should handle _rl_last_command_was_kill better */
 163           else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 164             _rl_internal_char_cleanup ();
 165
 166           return;
 167         }
 168       else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 169         {
 170           eof = _rl_dispatch_callback (_rl_kscxt);      /* For now */
 171           while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
 172             eof = _rl_dispatch_callback (_rl_kscxt);
 173           if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
 174             {
 175               _rl_internal_char_cleanup ();
 176               _rl_want_redisplay = 1;
 177             }
 178         }
 179       else if (_rl_callback_func)
 180         {
 181           /* This allows functions that simply need to read an additional
 182              character (like quoted-insert) to register a function to be
 183              called when input is available.  _rl_callback_data is simply a
 184              pointer to a struct that has the argument count originally
 185              passed to the registering function and space for any additional
 186              parameters.  */
 187           eof = (*_rl_callback_func) (_rl_callback_data);
 188           /* If the function `deregisters' itself, make sure the data is
 189              cleaned up. */
 190           if (_rl_callback_func == 0)
 191             {
 192               if (_rl_callback_data)
 193                 {
 194                   _rl_callback_data_dispose (_rl_callback_data);
 195                   _rl_callback_data = 0;
 196                 }
 197               _rl_internal_char_cleanup ();
 198             }
 199         }
 200       else
 201         eof = readline_internal_char ();
 202
 203       RL_CHECK_SIGNALS ();
 204       if (rl_done == 0 && _rl_want_redisplay)
 205         {
 206           (*rl_redisplay_function) ();
 207           _rl_want_redisplay = 0;
 208         }
 209
 210       if (rl_done)
 211         {
 212           line = readline_internal_teardown (eof);
 213
 214           if (rl_deprep_term_function)
 215             (*rl_deprep_term_function) ();
 216 #if defined (HANDLE_SIGNALS)
 217           rl_clear_signals ();
 218 #endif
 219           in_handler = 0;
 220           (*rl_linefunc) (line);
 221
 222           /* If the user did not clear out the line, do it for him. */
 223           if (rl_line_buffer[0])
 224             _rl_init_line_state ();
 225
 226           /* Redisplay the prompt if readline_handler_{install,remove}
 227              not called. */
 228           if (in_handler == 0 && rl_linefunc)
 229             _rl_callback_newline ();
 230         }
 231     }
 232   while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
 233 }
 234
 235 /* Remove the handler, and make sure the terminal is in its normal state. */
 236 void
 237 rl_callback_handler_remove ()
 238 {
 239   rl_linefunc = NULL;
 240   RL_UNSETSTATE (RL_STATE_CALLBACK);
 241   RL_CHECK_SIGNALS ();
 242   if (in_handler)
 243     {
 244       in_handler = 0;
 245       if (rl_deprep_term_function)
 246         (*rl_deprep_term_function) ();
 247 #if defined (HANDLE_SIGNALS)
 248       rl_clear_signals ();
 249 #endif
 250     }
 251 }
 252
 253 _rl_callback_generic_arg *
 254 _rl_callback_data_alloc (count)
 255      int count;
 256 {
 257   _rl_callback_generic_arg *arg;
 258
 259   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
 260   arg->count = count;
 261
 262   arg->i1 = arg->i2 = 0;
 263
 264   return arg;
 265 }
 266
 267 void _rl_callback_data_dispose (arg)
 268      _rl_callback_generic_arg *arg;
 269 {
 270   xfree (arg);
 271 }
 272
 273 #endif