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
  47 /* Private data for callback registration functions.  See comments in
  48    rl_callback_read_char for more details. */
  49 _rl_callback_func_t *_rl_callback_func = 0;
  50 _rl_callback_generic_arg *_rl_callback_data = 0;
  51
  52 /* **************************************************************** */
  53 /*                                                                  */
  54 /*                      Callback Readline Functions              */
  55 /*                                                                  */
  56 /* **************************************************************** */
  57
  58 /* Allow using readline in situations where a program may have multiple
  59    things to handle at once, and dispatches them via select().  Call
  60    rl_callback_handler_install() with the prompt and a function to call
  61    whenever a complete line of input is ready.  The user must then
  62    call rl_callback_read_char() every time some input is available, and
  63    rl_callback_read_char() will call the user's function with the complete
  64    text read in at each end of line.  The terminal is kept prepped and
  65    signals handled all the time, except during calls to the user's function. */
  66
  67 rl_vcpfunc_t *rl_linefunc;              /* user callback function */
  68 static int in_handler;          /* terminal_prepped and signals set? */
  69
  70 /* Make sure the terminal is set up, initialize readline, and prompt. */
  71 static void
  72 _rl_callback_newline ()
  73 {
  74   rl_initialize ();
  75
  76   if (in_handler == 0)
  77     {
  78       in_handler = 1;
  79
  80       if (rl_prep_term_function)
  81         (*rl_prep_term_function) (_rl_meta_flag);
  82
  83 #if defined (HANDLE_SIGNALS)
  84       rl_set_signals ();
  85 #endif
  86     }
  87
  88   readline_internal_setup ();
  89 }
  90
  91 /* Install a readline handler, set up the terminal, and issue the prompt. */
  92 void
  93 rl_callback_handler_install (prompt, linefunc)
  94      const char *prompt;
  95      rl_vcpfunc_t *linefunc;
  96 {
  97   rl_set_prompt (prompt);
  98   RL_SETSTATE (RL_STATE_CALLBACK);
  99   rl_linefunc = linefunc;
 100   _rl_callback_newline ();
 101 }
 102
 103 /* Read one character, and dispatch to the handler if it ends the line. */
 104 void
 105 rl_callback_read_char ()
 106 {
 107   char *line;
 108   int eof, jcode;
 109   static procenv_t olevel;
 110
 111   if (rl_linefunc == NULL)
 112     {
 113       fprintf (stderr, "readline: readline_callback_read_char() called with no handler!\r\n");
 114       abort ();
 115     }
 116
 117   memcpy ((void *)olevel, (void *)readline_top_level, sizeof (procenv_t));
 118   jcode = setjmp (readline_top_level);
 119   if (jcode)
 120     {
 121       (*rl_redisplay_function) ();
 122       _rl_want_redisplay = 0;
 123       memcpy ((void *)readline_top_level, (void *)olevel, sizeof (procenv_t));
 124       return;
 125     }
 126
 127   if  (RL_ISSTATE (RL_STATE_ISEARCH))
 128     {
 129       eof = _rl_isearch_callback (_rl_iscxt);
 130       if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 131         rl_callback_read_char ();
 132
 133       return;
 134     }
 135   else if  (RL_ISSTATE (RL_STATE_NSEARCH))
 136     {
 137       eof = _rl_nsearch_callback (_rl_nscxt);
 138       return;
 139     }
 140   else if (RL_ISSTATE (RL_STATE_NUMERICARG))
 141     {
 142       eof = _rl_arg_callback (_rl_argcxt);
 143       if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
 144         rl_callback_read_char ();
 145       /* XXX - this should handle _rl_last_command_was_kill better */
 146       else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
 147         _rl_internal_char_cleanup ();
 148
 149       return;
 150     }
 151   else if (RL_ISSTATE (RL_STATE_MULTIKEY))
 152     {
 153       eof = _rl_dispatch_callback (_rl_kscxt);  /* For now */
 154       while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
 155         eof = _rl_dispatch_callback (_rl_kscxt);
 156       if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
 157         {
 158           _rl_internal_char_cleanup ();
 159           _rl_want_redisplay = 1;
 160         }
 161     }
 162   else if (_rl_callback_func)
 163     {
 164       /* This allows functions that simply need to read an additional character
 165          (like quoted-insert) to register a function to be called when input is
 166          available.  _rl_callback_data is simply a pointer to a struct that has
 167          the argument count originally passed to the registering function and
 168          space for any additional parameters.  */
 169       eof = (*_rl_callback_func) (_rl_callback_data);
 170       /* If the function `deregisters' itself, make sure the data is cleaned
 171          up. */
 172       if (_rl_callback_func == 0)
 173         {
 174           if (_rl_callback_data)
 175             {
 176               _rl_callback_data_dispose (_rl_callback_data);
 177               _rl_callback_data = 0;
 178             }
 179           _rl_internal_char_cleanup ();
 180         }
 181     }
 182   else
 183     eof = readline_internal_char ();
 184
 185   if (rl_done == 0 && _rl_want_redisplay)
 186     {
 187       (*rl_redisplay_function) ();
 188       _rl_want_redisplay = 0;
 189     }
 190
 191   /* We loop in case some function has pushed input back with rl_execute_next. */
 192   for (;;)
 193     {
 194       if (rl_done)
 195         {
 196           line = readline_internal_teardown (eof);
 197
 198           if (rl_deprep_term_function)
 199             (*rl_deprep_term_function) ();
 200 #if defined (HANDLE_SIGNALS)
 201           rl_clear_signals ();
 202 #endif
 203           in_handler = 0;
 204           (*rl_linefunc) (line);
 205
 206           /* If the user did not clear out the line, do it for him. */
 207           if (rl_line_buffer[0])
 208             _rl_init_line_state ();
 209
 210           /* Redisplay the prompt if readline_handler_{install,remove}
 211              not called. */
 212           if (in_handler == 0 && rl_linefunc)
 213             _rl_callback_newline ();
 214         }
 215       if (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT))
 216         eof = readline_internal_char ();
 217       else
 218         break;
 219     }
 220 }
 221
 222 /* Remove the handler, and make sure the terminal is in its normal state. */
 223 void
 224 rl_callback_handler_remove ()
 225 {
 226   rl_linefunc = NULL;
 227   RL_UNSETSTATE (RL_STATE_CALLBACK);
 228   if (in_handler)
 229     {
 230       in_handler = 0;
 231       if (rl_deprep_term_function)
 232         (*rl_deprep_term_function) ();
 233 #if defined (HANDLE_SIGNALS)
 234       rl_clear_signals ();
 235 #endif
 236     }
 237 }
 238
 239 _rl_callback_generic_arg *
 240 _rl_callback_data_alloc (count)
 241      int count;
 242 {
 243   _rl_callback_generic_arg *arg;
 244
 245   arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
 246   arg->count = count;
 247
 248   arg->i1 = arg->i2 = 0;
 249
 250   return arg;
 251 }
 252
 253 void _rl_callback_data_dispose (arg)
 254      _rl_callback_generic_arg *arg;
 255 {
 256   if (arg)
 257     free (arg);
 258 }
 259
 260 #endif