Annotation of embedaddon/readline/callback.c, revision 1.1
1.1 ! misho 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
! 66: all the time, except during calls to the user's function. Signal
! 67: handlers are only installed when the application calls back into
! 68: readline, so readline doesn't `steal' signals from the application. */
! 69:
! 70: rl_vcpfunc_t *rl_linefunc; /* user callback function */
! 71: static int in_handler; /* terminal_prepped and signals set? */
! 72:
! 73: /* Make sure the terminal is set up, initialize readline, and prompt. */
! 74: static void
! 75: _rl_callback_newline ()
! 76: {
! 77: rl_initialize ();
! 78:
! 79: if (in_handler == 0)
! 80: {
! 81: in_handler = 1;
! 82:
! 83: if (rl_prep_term_function)
! 84: (*rl_prep_term_function) (_rl_meta_flag);
! 85: }
! 86:
! 87: readline_internal_setup ();
! 88: RL_CHECK_SIGNALS ();
! 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: #if defined (HANDLE_SIGNALS)
! 104: #define CALLBACK_READ_RETURN() \
! 105: do { \
! 106: rl_clear_signals (); \
! 107: return; \
! 108: } while (0)
! 109: #else
! 110: #define CALLBACK_READ_RETURN() return
! 111: #endif
! 112:
! 113: /* Read one character, and dispatch to the handler if it ends the line. */
! 114: void
! 115: rl_callback_read_char ()
! 116: {
! 117: char *line;
! 118: int eof, jcode;
! 119: static procenv_t olevel;
! 120:
! 121: if (rl_linefunc == NULL)
! 122: {
! 123: _rl_errmsg ("readline_callback_read_char() called with no handler!");
! 124: abort ();
! 125: }
! 126:
! 127: memcpy ((void *)olevel, (void *)_rl_top_level, sizeof (procenv_t));
! 128: #if defined (HAVE_POSIX_SIGSETJMP)
! 129: jcode = sigsetjmp (_rl_top_level, 0);
! 130: #else
! 131: jcode = setjmp (_rl_top_level);
! 132: #endif
! 133: if (jcode)
! 134: {
! 135: (*rl_redisplay_function) ();
! 136: _rl_want_redisplay = 0;
! 137: memcpy ((void *)_rl_top_level, (void *)olevel, sizeof (procenv_t));
! 138: CALLBACK_READ_RETURN ();
! 139: }
! 140:
! 141: #if defined (HANDLE_SIGNALS)
! 142: /* Install signal handlers only when readline has control. */
! 143: rl_set_signals ();
! 144: #endif
! 145:
! 146: do
! 147: {
! 148: RL_CHECK_SIGNALS ();
! 149: if (RL_ISSTATE (RL_STATE_ISEARCH))
! 150: {
! 151: eof = _rl_isearch_callback (_rl_iscxt);
! 152: if (eof == 0 && (RL_ISSTATE (RL_STATE_ISEARCH) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
! 153: rl_callback_read_char ();
! 154:
! 155: CALLBACK_READ_RETURN ();
! 156: }
! 157: else if (RL_ISSTATE (RL_STATE_NSEARCH))
! 158: {
! 159: eof = _rl_nsearch_callback (_rl_nscxt);
! 160:
! 161: CALLBACK_READ_RETURN ();
! 162: }
! 163: #if defined (VI_MODE)
! 164: else if (RL_ISSTATE (RL_STATE_VIMOTION))
! 165: {
! 166: eof = _rl_vi_domove_callback (_rl_vimvcxt);
! 167: /* Should handle everything, including cleanup, numeric arguments,
! 168: and turning off RL_STATE_VIMOTION */
! 169: if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
! 170: _rl_internal_char_cleanup ();
! 171:
! 172: CALLBACK_READ_RETURN ();
! 173: }
! 174: #endif
! 175: else if (RL_ISSTATE (RL_STATE_NUMERICARG))
! 176: {
! 177: eof = _rl_arg_callback (_rl_argcxt);
! 178: if (eof == 0 && (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) && RL_ISSTATE (RL_STATE_INPUTPENDING))
! 179: rl_callback_read_char ();
! 180: /* XXX - this should handle _rl_last_command_was_kill better */
! 181: else if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0)
! 182: _rl_internal_char_cleanup ();
! 183:
! 184: CALLBACK_READ_RETURN ();
! 185: }
! 186: else if (RL_ISSTATE (RL_STATE_MULTIKEY))
! 187: {
! 188: eof = _rl_dispatch_callback (_rl_kscxt); /* For now */
! 189: while ((eof == -1 || eof == -2) && RL_ISSTATE (RL_STATE_MULTIKEY) && _rl_kscxt && (_rl_kscxt->flags & KSEQ_DISPATCHED))
! 190: eof = _rl_dispatch_callback (_rl_kscxt);
! 191: if (RL_ISSTATE (RL_STATE_MULTIKEY) == 0)
! 192: {
! 193: _rl_internal_char_cleanup ();
! 194: _rl_want_redisplay = 1;
! 195: }
! 196: }
! 197: else if (_rl_callback_func)
! 198: {
! 199: /* This allows functions that simply need to read an additional
! 200: character (like quoted-insert) to register a function to be
! 201: called when input is available. _rl_callback_data is a
! 202: pointer to a struct that has the argument count originally
! 203: passed to the registering function and space for any additional
! 204: parameters. */
! 205: eof = (*_rl_callback_func) (_rl_callback_data);
! 206: /* If the function `deregisters' itself, make sure the data is
! 207: cleaned up. */
! 208: if (_rl_callback_func == 0)
! 209: {
! 210: if (_rl_callback_data)
! 211: {
! 212: _rl_callback_data_dispose (_rl_callback_data);
! 213: _rl_callback_data = 0;
! 214: }
! 215: _rl_internal_char_cleanup ();
! 216: }
! 217: }
! 218: else
! 219: eof = readline_internal_char ();
! 220:
! 221: RL_CHECK_SIGNALS ();
! 222: if (rl_done == 0 && _rl_want_redisplay)
! 223: {
! 224: (*rl_redisplay_function) ();
! 225: _rl_want_redisplay = 0;
! 226: }
! 227:
! 228: if (rl_done)
! 229: {
! 230: line = readline_internal_teardown (eof);
! 231:
! 232: if (rl_deprep_term_function)
! 233: (*rl_deprep_term_function) ();
! 234: #if defined (HANDLE_SIGNALS)
! 235: rl_clear_signals ();
! 236: #endif
! 237: in_handler = 0;
! 238: (*rl_linefunc) (line);
! 239:
! 240: /* If the user did not clear out the line, do it for him. */
! 241: if (rl_line_buffer[0])
! 242: _rl_init_line_state ();
! 243:
! 244: /* Redisplay the prompt if readline_handler_{install,remove}
! 245: not called. */
! 246: if (in_handler == 0 && rl_linefunc)
! 247: _rl_callback_newline ();
! 248: }
! 249: }
! 250: while (rl_pending_input || _rl_pushed_input_available () || RL_ISSTATE (RL_STATE_MACROINPUT));
! 251:
! 252: CALLBACK_READ_RETURN ();
! 253: }
! 254:
! 255: /* Remove the handler, and make sure the terminal is in its normal state. */
! 256: void
! 257: rl_callback_handler_remove ()
! 258: {
! 259: rl_linefunc = NULL;
! 260: RL_UNSETSTATE (RL_STATE_CALLBACK);
! 261: RL_CHECK_SIGNALS ();
! 262: if (in_handler)
! 263: {
! 264: in_handler = 0;
! 265: if (rl_deprep_term_function)
! 266: (*rl_deprep_term_function) ();
! 267: #if defined (HANDLE_SIGNALS)
! 268: rl_clear_signals ();
! 269: #endif
! 270: }
! 271: }
! 272:
! 273: _rl_callback_generic_arg *
! 274: _rl_callback_data_alloc (count)
! 275: int count;
! 276: {
! 277: _rl_callback_generic_arg *arg;
! 278:
! 279: arg = (_rl_callback_generic_arg *)xmalloc (sizeof (_rl_callback_generic_arg));
! 280: arg->count = count;
! 281:
! 282: arg->i1 = arg->i2 = 0;
! 283:
! 284: return arg;
! 285: }
! 286:
! 287: void _rl_callback_data_dispose (arg)
! 288: _rl_callback_generic_arg *arg;
! 289: {
! 290: xfree (arg);
! 291: }
! 292:
! 293: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to callback.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline