readline/callback.c

   1 /* callback.c -- functions to use readline as an X `callback' mechanism. */
   2
   3 /* Copyright (C) 1987-2005 Free Software Foundation, Inc.
   4
   5    This file is part of the GNU Readline Library, a library for
   6    reading lines of text with interactive input and history editing.
   7
   8    The GNU Readline Library is free software; you can redistribute it
   9    and/or modify it under the terms of the GNU General Public License
  10    as published by the Free Software Foundation; either version 2, or
  11    (at your option) any later version.
  12
  13    The GNU Readline Library is distributed in the hope that it will be
  14    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  15    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    The GNU General Public License is often shipped with GNU software, and
  19    is generally kept in a file called COPYING or LICENSE.  If you do not
  20    have a copy of the license, write to the Free Software Foundation,
  21    59 Temple Place, Suite 330, Boston, MA 02111 USA. */
  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 }
  91
  92 /* Install a readline handler, set up the terminal, and issue the prompt. */
  93 void
  94 rl_callback_handler_install (prompt, linefunc)
  95      const char *prompt;
  96      rl_vcpfunc_t *linefunc;
  97 {
  98   rl_set_prompt (prompt);
  99   RL_SETSTATE (RL_STATE_CALLBACK);
 100   rl_linefunc = linefunc;
 101   _rl_callback_newline ();
 102 }
 103
 104 /* Read one character, and dispatch to the handler if it ends the line. */
 105 void
 106 rl_callback_read_char ()
 107 {
 108   char *line;
 109   int eof, jcode;
 110   static procenv_t olevel;
 111
 112   if (rl_linefunc == NULL)
 113     {
 114       fprintf (stderr, "readline: readline_callback_read_char() called with no handler!\r\n");
 115       abort ();
 116     }
 117
 118   memcpy ((void *)olevel, (void *)readline_top_level, sizeof (procenv_t));
 119   jcode = setjmp (readline_top_level);
 120   if (jcode)
 121     {
 122       (*rl_redisplay_function) ();
 123       _rl_want_redisplay = 0;
 124       memcpy ((void *)readline_top_level, (void *)olevel, sizeof (procenv_t));
 125       return;
 126     }
 127
 128   if  (RL_ISSTATE (RL_STATE_ISEARCH))
 129     {
 130       eof = _rl_isearch_callback (_rl_iscxt);
 131       if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 132         rl_callback_read_char ();
 133
 134       return;
 135     }
 136   else if  (RL_ISSTATE (RL_STATE_NSEARCH))
 137     {
 138       eof = _rl_nsearch_callback (_rl_nscxt);
 139       return;
 140     }
 141   else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 142     {
 143       eof = _rl_arg_callback (_rl_argcxt);
 144       if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 145         rl_callback_read_char ();
 146       /* XXX - this should handle _rl_last_command_was_kill better */
 147       else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 148         _rl_internal_char_cleanup ();
 149
 150       return;
 151     }
 152   else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 153     {
 154       eof = _rl_dispatch_callback (_rl_kscxt);  /* For now */
 155       while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
 156         eof = _rl_dispatch_callback (_rl_kscxt);
 157       if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
 158         {
 159           _rl_internal_char_cleanup ();
 160           _rl_want_redisplay = 1;
 161         }
 162     }
 163   else if (_rl_callback_func)
 164     {
 165       /* This allows functions that simply need to read an additional character
 166          (like quoted-insert) to register a function to be called when input is
 167          available.  _rl_callback_data is simply a pointer to a struct that has
 168          the argument count originally passed to the registering function and
 169          space for any additional parameters.  */
 170       eof = (*_rl_callback_func) (_rl_callback_data);
 171       /* If the function `deregisters' itself, make sure the data is cleaned
 172          up. */
 173       if (_rl_callback_func == 0)
 174         {
 175           if (_rl_callback_data)
 176             {
 177               _rl_callback_data_dispose (_rl_callback_data);
 178               _rl_callback_data = 0;
 179             }
 180           _rl_internal_char_cleanup ();
 181         }
 182     }
 183   else
 184     eof = readline_internal_char ();
 185
 186   if (rl_done == 0 && _rl_want_redisplay)
 187     {
 188       (*rl_redisplay_function) ();
 189       _rl_want_redisplay = 0;
 190     }
 191
 192   /* We loop in case some function has pushed input back with rl_execute_next. */
 193   for (;;)
 194     {
 195       if (rl_done)
 196         {
 197           line = readline_internal_teardown (eof);
 198
 199           if (rl_deprep_term_function)
 200             (*rl_deprep_term_function) ();
 201 #if defined (HANDLE_SIGNALS)
 202           rl_clear_signals ();
 203 #endif
 204           in_handler = 0;
 205           (*rl_linefunc) (line);
 206
 207           /* If the user did not clear out the line, do it for him. */
 208           if (rl_line_buffer[0])
 209             _rl_init_line_state ();
 210
 211           /* Redisplay the prompt if readline_handler_{install,remove}
 212              not called. */
 213           if (in_handler == 0 && rl_linefunc)
 214             _rl_callback_newline ();
 215         }
 216       if (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT))
 217         eof = readline_internal_char ();
 218       else
 219         break;
 220     }
 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   if (in_handler)
 230     {
 231       in_handler = 0;
 232       if (rl_deprep_term_function)
 233         (*rl_deprep_term_function) ();
 234 #if defined (HANDLE_SIGNALS)
 235       rl_clear_signals ();
 236 #endif
 237     }
 238 }
 239
 240 _rl_callback_generic_arg *
 241 _rl_callback_data_alloc (count)
 242      int count;
 243 {
 244   _rl_callback_generic_arg *arg;
 245
 246   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
 247   arg->count = count;
 248
 249   arg->i1 = arg->i2 = 0;
 250
 251   return arg;
 252 }
 253
 254 void _rl_callback_data_dispose (arg)
 255      _rl_callback_generic_arg *arg;
 256 {
 257   if (arg)
 258     free (arg);
 259 }
 260
 261 #endif