lib/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       else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 146         {
 147           eof = _rl_arg_callback (_rl_argcxt);
 148           if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 149             rl_callback_read_char ();
 150           /* XXX - this should handle _rl_last_command_was_kill better */
 151           else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 152             _rl_internal_char_cleanup ();
 153
 154           return;
 155         }
 156       else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 157         {
 158           eof = _rl_dispatch_callback (_rl_kscxt);      /* For now */
 159           while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
 160             eof = _rl_dispatch_callback (_rl_kscxt);
 161           if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
 162             {
 163               _rl_internal_char_cleanup ();
 164               _rl_want_redisplay = 1;
 165             }
 166         }
 167       else if (_rl_callback_func)
 168         {
 169           /* This allows functions that simply need to read an additional
 170              character (like quoted-insert) to register a function to be
 171              called when input is available.  _rl_callback_data is simply a
 172              pointer to a struct that has the argument count originally
 173              passed to the registering function and space for any additional
 174              parameters.  */
 175           eof = (*_rl_callback_func) (_rl_callback_data);
 176           /* If the function `deregisters' itself, make sure the data is
 177              cleaned up. */
 178           if (_rl_callback_func == 0)
 179             {
 180               if (_rl_callback_data)
 181                 {
 182                   _rl_callback_data_dispose (_rl_callback_data);
 183                   _rl_callback_data = 0;
 184                 }
 185               _rl_internal_char_cleanup ();
 186             }
 187         }
 188       else
 189         eof = readline_internal_char ();
 190
 191       RL_CHECK_SIGNALS ();
 192       if (rl_done == 0 && _rl_want_redisplay)
 193         {
 194           (*rl_redisplay_function) ();
 195           _rl_want_redisplay = 0;
 196         }
 197
 198       if (rl_done)
 199         {
 200           line = readline_internal_teardown (eof);
 201
 202           if (rl_deprep_term_function)
 203             (*rl_deprep_term_function) ();
 204 #if defined (HANDLE_SIGNALS)
 205           rl_clear_signals ();
 206 #endif
 207           in_handler = 0;
 208           (*rl_linefunc) (line);
 209
 210           /* If the user did not clear out the line, do it for him. */
 211           if (rl_line_buffer[0])
 212             _rl_init_line_state ();
 213
 214           /* Redisplay the prompt if readline_handler_{install,remove}
 215              not called. */
 216           if (in_handler == 0 && rl_linefunc)
 217             _rl_callback_newline ();
 218         }
 219     }
 220   while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
 221 }
 222
 223 /* Remove the handler, and make sure the terminal is in its normal state. */
 224 void
 225 rl_callback_handler_remove ()
 226 {
 227   rl_linefunc = NULL;
 228   RL_UNSETSTATE (RL_STATE_CALLBACK);
 229   RL_CHECK_SIGNALS ();
 230   if (in_handler)
 231     {
 232       in_handler = 0;
 233       if (rl_deprep_term_function)
 234         (*rl_deprep_term_function) ();
 235 #if defined (HANDLE_SIGNALS)
 236       rl_clear_signals ();
 237 #endif
 238     }
 239 }
 240
 241 _rl_callback_generic_arg *
 242 _rl_callback_data_alloc (count)
 243      int count;
 244 {
 245   _rl_callback_generic_arg *arg;
 246
 247   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
 248   arg->count = count;
 249
 250   arg->i1 = arg->i2 = 0;
 251
 252   return arg;
 253 }
 254
 255 void _rl_callback_data_dispose (arg)
 256      _rl_callback_generic_arg *arg;
 257 {
 258   xfree (arg);
 259 }
 260
 261 #endif