readline/callback.c

   1 /* callback.c -- functions to use readline as an X `callback' mechanism. */
   2
   3 /* Copyright (C) 1987-2015 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 /* Applications can set this to non-zero to have readline's signal handlers
  54    installed during the entire duration of reading a complete line, as in
  55    readline-6.2.  This should be used with care, because it can result in
  56    readline receiving signals and not handling them until it's called again
  57    via rl_callback_read_char, thereby stealing them from the application.
  58    By default, signal handlers are only active while readline is active. */
  59 int rl_persistent_signal_handlers = 0;
  60
  61 /* **************************************************************** */
  62 /*                                                                  */
  63 /*                      Callback Readline Functions              */
  64 /*                                                                  */
  65 /* **************************************************************** */
  66
  67 /* Allow using readline in situations where a program may have multiple
  68    things to handle at once, and dispatches them via select().  Call
  69    rl_callback_handler_install() with the prompt and a function to call
  70    whenever a complete line of input is ready.  The user must then
  71    call rl_callback_read_char() every time some input is available, and
  72    rl_callback_read_char() will call the user's function with the complete
  73    text read in at each end of line.  The terminal is kept prepped
  74    all the time, except during calls to the user's function.  Signal
  75    handlers are only installed when the application calls back into
  76    readline, so readline doesn't `steal' signals from the application.  */
  77
  78 rl_vcpfunc_t *rl_linefunc;              /* user callback function */
  79 static int in_handler;          /* terminal_prepped and signals set? */
  80
  81 /* Make sure the terminal is set up, initialize readline, and prompt. */
  82 static void
  83 _rl_callback_newline ()
  84 {
  85   rl_initialize ();
  86
  87   if (in_handler == 0)
  88     {
  89       in_handler = 1;
  90
  91       if (rl_prep_term_function)
  92         (*rl_prep_term_function) (_rl_meta_flag);
  93
  94 #if defined (HANDLE_SIGNALS)
  95       if (rl_persistent_signal_handlers)
  96         rl_set_signals ();
  97 #endif
  98     }
  99
 100   readline_internal_setup ();
 101   RL_CHECK_SIGNALS ();
 102 }
 103
 104 /* Install a readline handler, set up the terminal, and issue the prompt. */
 105 void
 106 rl_callback_handler_install (prompt, linefunc)
 107      const char *prompt;
 108      rl_vcpfunc_t *linefunc;
 109 {
 110   rl_set_prompt (prompt);
 111   RL_SETSTATE (RL_STATE_CALLBACK);
 112   rl_linefunc = linefunc;
 113   _rl_callback_newline ();
 114 }
 115
 116 #if defined (HANDLE_SIGNALS)
 117 #define CALLBACK_READ_RETURN() \
 118   do { \
 119     if (rl_persistent_signal_handlers == 0) \
 120       rl_clear_signals (); \
 121     return; \
 122   } while (0)
 123 #else
 124 #define CALLBACK_READ_RETURN() return
 125 #endif
 126
 127 /* Read one character, and dispatch to the handler if it ends the line. */
 128 void
 129 rl_callback_read_char ()
 130 {
 131   char *line;
 132   int eof, jcode;
 133   static procenv_t olevel;
 134
 135   if (rl_linefunc == NULL)
 136     {
 137       _rl_errmsg ("readline_callback_read_char() called with no handler!");
 138       abort ();
 139     }
 140
 141   memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t));
 142 #if defined (HAVE_POSIX_SIGSETJMP)
 143   jcode = sigsetjmp (_rl_top_level, 0);
 144 #else
 145   jcode = setjmp (_rl_top_level);
 146 #endif
 147   if (jcode)
 148     {
 149       (*rl_redisplay_function) ();
 150       _rl_want_redisplay = 0;
 151       memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t));
 152       CALLBACK_READ_RETURN ();
 153     }
 154
 155 #if defined (HANDLE_SIGNALS)
 156   /* Install signal handlers only when readline has control. */
 157   if (rl_persistent_signal_handlers == 0)
 158     rl_set_signals ();
 159 #endif
 160
 161   do
 162     {
 163       RL_CHECK_SIGNALS ();
 164       if  (RL_ISSTATE (RL_STATE_ISEARCH))
 165         {
 166           eof = _rl_isearch_callback (_rl_iscxt);
 167           if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 168             rl_callback_read_char ();
 169
 170           CALLBACK_READ_RETURN ();
 171         }
 172       else if  (RL_ISSTATE (RL_STATE_NSEARCH))
 173         {
 174           eof = _rl_nsearch_callback (_rl_nscxt);
 175
 176           CALLBACK_READ_RETURN ();
 177         }
 178 #if defined (VI_MODE)
 179       /* States that can occur while in state VIMOTION have to be checked
 180          before RL_STATE_VIMOTION */
 181       else if (RL_ISSTATE (RL_STATE_CHARSEARCH))
 182         {
 183           int k;
 184
 185           k = _rl_callback_data->i2;
 186
 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)   /* XXX - just sanity check */
 191             {
 192               if (_rl_callback_data)
 193                 {
 194                   _rl_callback_data_dispose (_rl_callback_data);
 195                   _rl_callback_data = 0;
 196                 }
 197             }
 198
 199           /* Messy case where vi motion command can be char search */
 200           if (RL_ISSTATE (RL_STATE_VIMOTION))
 201             {
 202               _rl_vi_domove_motion_cleanup (k, _rl_vimvcxt);
 203               _rl_internal_char_cleanup ();
 204               CALLBACK_READ_RETURN ();
 205             }
 206
 207           _rl_internal_char_cleanup ();
 208         }
 209       else if (RL_ISSTATE (RL_STATE_VIMOTION))
 210         {
 211           eof = _rl_vi_domove_callback (_rl_vimvcxt);
 212           /* Should handle everything, including cleanup, numeric arguments,
 213              and turning off RL_STATE_VIMOTION */
 214           if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 215             _rl_internal_char_cleanup ();
 216
 217           CALLBACK_READ_RETURN ();
 218         }
 219 #endif
 220       else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 221         {
 222           eof = _rl_arg_callback (_rl_argcxt);
 223           if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 224             rl_callback_read_char ();
 225           /* XXX - this should handle _rl_last_command_was_kill better */
 226           else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 227             _rl_internal_char_cleanup ();
 228
 229           CALLBACK_READ_RETURN ();
 230         }
 231       else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 232         {
 233           eof = _rl_dispatch_callback (_rl_kscxt);      /* For now */
 234           while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
 235             eof = _rl_dispatch_callback (_rl_kscxt);
 236           if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
 237             {
 238               _rl_internal_char_cleanup ();
 239               _rl_want_redisplay = 1;
 240             }
 241         }
 242       else if (_rl_callback_func)
 243         {
 244           /* This allows functions that simply need to read an additional
 245              character (like quoted-insert) to register a function to be
 246              called when input is available.  _rl_callback_data is a
 247              pointer to a struct that has the argument count originally
 248              passed to the registering function and space for any additional
 249              parameters.  */
 250           eof = (*_rl_callback_func) (_rl_callback_data);
 251           /* If the function `deregisters' itself, make sure the data is
 252              cleaned up. */
 253           if (_rl_callback_func == 0)
 254             {
 255               if (_rl_callback_data)
 256                 {
 257                   _rl_callback_data_dispose (_rl_callback_data);
 258                   _rl_callback_data = 0;
 259                 }
 260               _rl_internal_char_cleanup ();
 261             }
 262         }
 263       else
 264         eof = readline_internal_char ();
 265
 266       RL_CHECK_SIGNALS ();
 267       if (rl_done == 0 && _rl_want_redisplay)
 268         {
 269           (*rl_redisplay_function) ();
 270           _rl_want_redisplay = 0;
 271         }
 272
 273       if (rl_done)
 274         {
 275           line = readline_internal_teardown (eof);
 276
 277           if (rl_deprep_term_function)
 278             (*rl_deprep_term_function) ();
 279 #if defined (HANDLE_SIGNALS)
 280           rl_clear_signals ();
 281 #endif
 282           in_handler = 0;
 283           (*rl_linefunc) (line);
 284
 285           /* If the user did not clear out the line, do it for him. */
 286           if (rl_line_buffer[0])
 287             _rl_init_line_state ();
 288
 289           /* Redisplay the prompt if readline_handler_{install,remove}
 290              not called. */
 291           if (in_handler == 0 && rl_linefunc)
 292             _rl_callback_newline ();
 293         }
 294     }
 295   while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
 296
 297   CALLBACK_READ_RETURN ();
 298 }
 299
 300 /* Remove the handler, and make sure the terminal is in its normal state. */
 301 void
 302 rl_callback_handler_remove ()
 303 {
 304   rl_linefunc = NULL;
 305   RL_UNSETSTATE (RL_STATE_CALLBACK);
 306   RL_CHECK_SIGNALS ();
 307   if (in_handler)
 308     {
 309       in_handler = 0;
 310       if (rl_deprep_term_function)
 311         (*rl_deprep_term_function) ();
 312 #if defined (HANDLE_SIGNALS)
 313       rl_clear_signals ();
 314 #endif
 315     }
 316 }
 317
 318 _rl_callback_generic_arg *
 319 _rl_callback_data_alloc (count)
 320      int count;
 321 {
 322   _rl_callback_generic_arg *arg;
 323
 324   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
 325   arg->count = count;
 326
 327   arg->i1 = arg->i2 = 0;
 328
 329   return arg;
 330 }
 331
 332 void
 333 _rl_callback_data_dispose (arg)
 334      _rl_callback_generic_arg *arg;
 335 {
 336   xfree (arg);
 337 }
 338
 339 /* Make sure that this agrees with cases in rl_callback_read_char */
 340 void
 341 rl_callback_sigcleanup ()
 342 {
 343   if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
 344     return;
 345
 346   if (RL_ISSTATE (RL_STATE_ISEARCH))
 347     _rl_isearch_cleanup (_rl_iscxt, 0);
 348   else if (RL_ISSTATE (RL_STATE_NSEARCH))
 349     _rl_nsearch_cleanup (_rl_nscxt, 0);
 350   else if (RL_ISSTATE (RL_STATE_VIMOTION))
 351     RL_UNSETSTATE (RL_STATE_VIMOTION);
 352   else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 353     {
 354       _rl_argcxt = 0;
 355       RL_UNSETSTATE (RL_STATE_NUMERICARG);
 356     }
 357   else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 358     RL_UNSETSTATE (RL_STATE_MULTIKEY);
 359   if (RL_ISSTATE (RL_STATE_CHARSEARCH))
 360     RL_UNSETSTATE (RL_STATE_CHARSEARCH);
 361
 362   _rl_callback_func = 0;
 363 }
 364 #endif