MySQL 5.1: mysql/src/5.1-dbg/cmd-line-utils/libedit/el.c File Reference

mysql/src/5.1-dbg/cmd-line-utils/libedit/el.c File Reference

#include <config.h>
#include <sys/types.h>
#include <sys/param.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "el.h"

Include dependency graph for el.c:

Go to the source code of this file.


Functions
public EditLine *	el_init (const char prog, FILE fin, FILE fout, FILE ferr)
public void	el_end (EditLine *el)
public void	el_reset (EditLine *el)
public int	el_set (EditLine *el, int op,...)
public int	el_get (EditLine el, int op, void ret)
public const LineInfo *	el_line (EditLine *el)
public int	el_source (EditLine el, const char fname)
public void	el_resize (EditLine *el)
public void	el_beep (EditLine *el)
protected int	el_editmode (EditLine el, int argc, const char *argv)

Function Documentation

public void el_beep ( EditLine * el )

Definition at line 495 of file el.c.

References el, and term_beep().

Referenced by _rl_complete_internal().

00496 {
00497 
00498         term_beep(el);
00499 }

Here is the call graph for this function:

Here is the caller graph for this function:

protected int el_editmode	(	EditLine *	el,
		int	argc,
		const char **	argv
	)

Definition at line 507 of file el.c.

References EDIT_DISABLED, el, editline::el_errfile, editline::el_flags, NULL, strcmp(), tty_cookedmode(), and tty_rawmode().

00508 {
00509         const char *how;
00510 
00511         if (argv == NULL || argc != 2 || argv[1] == NULL)
00512                 return (-1);
00513 
00514         how = argv[1];
00515         if (strcmp(how, "on") == 0) {
00516                 el->el_flags &= ~EDIT_DISABLED;
00517                 tty_rawmode(el);
00518         } else if (strcmp(how, "off") == 0) {
00519                 tty_cookedmode(el);
00520                 el->el_flags |= EDIT_DISABLED;
00521         }
00522         else {
00523                 (void) fprintf(el->el_errfile, "edit: Bad value `%s'.\n", how);
00524                 return (-1);
00525         }
00526         return (0);
00527 }

Here is the call graph for this function:

public void el_end ( EditLine * el )

Definition at line 98 of file el.c.

References ch_end(), el, el_free, editline::el_prog, el_reset(), hist_end(), key_end(), map_end(), NULL, prompt_end(), search_end(), sig_end(), term_end(), and tty_end().

Referenced by main(), and rl_initialize().

00099 {
00100 
00101         if (el == NULL)
00102                 return;
00103 
00104         el_reset(el);
00105 
00106         term_end(el);
00107         key_end(el);
00108         map_end(el);
00109         tty_end(el);
00110         ch_end(el);
00111         search_end(el);
00112         hist_end(el);
00113         prompt_end(el);
00114         sig_end(el);
00115 
00116         el_free((ptr_t) el->el_prog);
00117         el_free((ptr_t) el);
00118 }

Here is the call graph for this function:

Here is the caller graph for this function:

public int el_get	(	EditLine *	el,
		int	op,
		void *	ret
	)

Definition at line 287 of file el.c.

References EDIT_DISABLED, el, EL_ABORT, EL_ADDFN, EL_BIND, EL_CLIENTDATA, editline::el_data, EL_ECHOTC, EL_EDITMODE, EL_EDITOR, editline::el_flags, EL_GETCFN, EL_HIST, EL_PROMPT, el_read_getfn(), EL_RPROMPT, EL_SETTC, EL_SETTY, EL_SIGNAL, EL_TELLTC, EL_TERMINAL, EL_UNBUFFERED, func, HANDLE_SIGNALS, hist_set(), map_addfunc(), map_bind(), map_get_editor(), name, NULL, prompt_get(), term_echotc(), term_get(), term_settc(), term_telltc(), tty_stty(), and UNBUFFERED.

Referenced by rl_initialize().

00288 {
00289         int rv;
00290 
00291         if (el == NULL || ret == NULL)
00292                 return (-1);
00293         switch (op) {
00294         case EL_PROMPT:
00295         case EL_RPROMPT:
00296                 rv = prompt_get(el, (void *) &ret, op);
00297                 break;
00298 
00299         case EL_EDITOR:
00300                 rv = map_get_editor(el, (void *) &ret);
00301                 break;
00302 
00303         case EL_SIGNAL:
00304                 *((int *) ret) = (el->el_flags & HANDLE_SIGNALS);
00305                 rv = 0;
00306                 break;
00307 
00308         case EL_EDITMODE:
00309                 *((int *) ret) = (!(el->el_flags & EDIT_DISABLED));
00310                 rv = 0;
00311                 break;
00312 
00313         case EL_TERMINAL:
00314                 term_get(el, (const char **)ret);
00315                 rv = 0;
00316                 break;
00317 
00318 #if 0                           /* XXX */
00319         case EL_BIND:
00320         case EL_TELLTC:
00321         case EL_SETTC:
00322         case EL_ECHOTC:
00323         case EL_SETTY:
00324         {
00325                 const char *argv[20];
00326                 int i;
00327 
00328                 for (i = 1; i < sizeof(argv) / sizeof(argv[0]); i++)
00329                         if ((argv[i] = va_arg(va, char *)) == NULL)
00330                                 break;
00331 
00332                 switch (op) {
00333                 case EL_BIND:
00334                         argv[0] = "bind";
00335                         rv = map_bind(el, i, argv);
00336                         break;
00337 
00338                 case EL_TELLTC:
00339                         argv[0] = "telltc";
00340                         rv = term_telltc(el, i, argv);
00341                         break;
00342 
00343                 case EL_SETTC:
00344                         argv[0] = "settc";
00345                         rv = term_settc(el, i, argv);
00346                         break;
00347 
00348                 case EL_ECHOTC:
00349                         argv[0] = "echotc";
00350                         rv = term_echotc(el, i, argv);
00351                         break;
00352 
00353                 case EL_SETTY:
00354                         argv[0] = "setty";
00355                         rv = tty_stty(el, i, argv);
00356                         break;
00357 
00358                 default:
00359                         rv = -1;
00360                         EL_ABORT((el->errfile, "Bad op %d\n", op));
00361                         break;
00362                 }
00363                 break;
00364         }
00365 
00366         case EL_ADDFN:
00367         {
00368                 char *name = va_arg(va, char *);
00369                 char *help = va_arg(va, char *);
00370                 el_func_t func = va_arg(va, el_func_t);
00371 
00372                 rv = map_addfunc(el, name, help, func);
00373                 break;
00374         }
00375 
00376         case EL_HIST:
00377                 {
00378                         hist_fun_t func = va_arg(va, hist_fun_t);
00379                         ptr_t ptr = va_arg(va, char *);
00380                         rv = hist_set(el, func, ptr);
00381                 }
00382                 break;
00383 #endif /* XXX */
00384 
00385         case EL_GETCFN:
00386                 *((el_rfunc_t *)ret) = el_read_getfn(el);
00387                 rv = 0;
00388                 break;
00389 
00390         case EL_CLIENTDATA:
00391                 *((void **)ret) = el->el_data;
00392                 rv = 0;
00393                 break;
00394 
00395         case EL_UNBUFFERED:
00396                 *((int *) ret) = (!(el->el_flags & UNBUFFERED));
00397                 rv = 0;
00398                 break;
00399 
00400         default:
00401                 rv = -1;
00402         }
00403 
00404         return (rv);
00405 }

Here is the call graph for this function:

Here is the caller graph for this function:

public EditLine* el_init	(	const char *	prog,
		FILE *	fin,
		FILE *	fout,
		FILE *	ferr
	)

Definition at line 51 of file el.c.

References ch_init(), el, editline::el_errfile, editline::el_flags, el_free, editline::el_infd, el_malloc, editline::el_outfile, editline::el_prog, el_strdup, hist_init(), key_init(), map_init(), memset, NO_TTY, NULL, prompt_init(), read_init(), search_init(), sig_init(), term_init(), and tty_init().

Referenced by main(), and rl_initialize().

00052 {
00053 
00054         EditLine *el = (EditLine *) el_malloc(sizeof(EditLine));
00055 
00056         if (el == NULL)
00057                 return (NULL);
00058 
00059         memset(el, 0, sizeof(EditLine));
00060 
00061         el->el_infd = fileno(fin);
00062         el->el_outfile = fout;
00063         el->el_errfile = ferr;
00064         if ((el->el_prog = el_strdup(prog)) == NULL) {
00065                 el_free(el);
00066                 return NULL;
00067         }
00068 
00069         /*
00070          * Initialize all the modules. Order is important!!!
00071          */
00072         el->el_flags = 0;
00073 
00074         if (term_init(el) == -1) {
00075                 el_free(el->el_prog);
00076                 el_free(el);
00077                 return NULL;
00078         }
00079         (void) key_init(el);
00080         (void) map_init(el);
00081         if (tty_init(el) == -1)
00082                 el->el_flags |= NO_TTY;
00083         (void) ch_init(el);
00084         (void) search_init(el);
00085         (void) hist_init(el);
00086         (void) prompt_init(el);
00087         (void) sig_init(el);
00088         (void) read_init(el);
00089 
00090         return (el);
00091 }

Here is the call graph for this function:

Here is the caller graph for this function:

public const LineInfo* el_line ( EditLine * el )

Definition at line 412 of file el.c.

References el, and editline::el_line.

Referenced by _rl_complete_internal(), _rl_update_pos(), c_delafter(), c_delafter1(), c_delbefore(), c_delbefore1(), complete(), cv_csearch(), ed_delete_prev_word(), ed_kill_line(), ed_next_line(), em_copy_region(), em_kill_line(), em_kill_region(), re_refresh_cursor(), vi_kill_line_prev(), and vi_match().

00413 {
00414 
00415         return (const LineInfo *) (void *) &el->el_line;
00416 }

Here is the caller graph for this function:

public void el_reset ( EditLine * el )

Definition at line 125 of file el.c.

References ch_reset(), el, and tty_cookedmode().

Referenced by el_end(), rl_reset_terminal(), and sig().

00126 {
00127 
00128         tty_cookedmode(el);
00129         ch_reset(el);           /* XXX: Do we want that? */
00130 }

Here is the call graph for this function:

Here is the caller graph for this function:

public void el_resize ( EditLine * el )

Definition at line 474 of file el.c.

References el, NULL, sigemptyset, term_change_size(), and term_get_size().

Referenced by read_prepare(), and sig_handler().

00475 {
00476         int lins, cols;
00477         sigset_t oset, nset;
00478 
00479         (void) sigemptyset(&nset);
00480         (void) sigaddset(&nset, SIGWINCH);
00481         (void) sigprocmask(SIG_BLOCK, &nset, &oset);
00482 
00483         /* get the correct window size */
00484         if (term_get_size(el, &lins, &cols))
00485                 term_change_size(el, lins, cols);
00486 
00487         (void) sigprocmask(SIG_SETMASK, &oset, NULL);
00488 }

Here is the call graph for this function:

Here is the caller graph for this function:

public int el_set	(	EditLine *	el,
		int	op,
			...
	)

Definition at line 137 of file el.c.

References EDIT_DISABLED, el, EL_ABORT, EL_ADDFN, EL_BIND, EL_CLIENTDATA, editline::el_data, EL_ECHOTC, EL_EDITMODE, EL_EDITOR, editline::el_errfile, editline::el_flags, EL_GETCFN, EL_HIST, EL_PREP_TERM, EL_PROMPT, el_read_setfn(), EL_RPROMPT, EL_SETTC, EL_SETTY, EL_SIGNAL, EL_TELLTC, EL_TERMINAL, EL_UNBUFFERED, func, HANDLE_SIGNALS, hist_set(), map_addfunc(), map_bind(), map_set_editor(), name, NULL, prompt_set(), read_finish(), read_prepare(), term_echotc(), term_set(), term_settc(), term_telltc(), tty_cookedmode(), tty_rawmode(), tty_stty(), and UNBUFFERED.

Referenced by _rl_event_read_char(), main(), readline(), rl_add_defun(), rl_callback_handler_install(), rl_callback_handler_remove(), rl_callback_read_char(), rl_deprep_terminal(), rl_initialize(), and rl_prep_terminal().

00138 {
00139         va_list va;
00140         int rv = 0;
00141 
00142         if (el == NULL)
00143                 return (-1);
00144         va_start(va, op);
00145 
00146         switch (op) {
00147         case EL_PROMPT:
00148         case EL_RPROMPT:
00149                 rv = prompt_set(el, va_arg(va, el_pfunc_t), op);
00150                 break;
00151 
00152         case EL_TERMINAL:
00153                 rv = term_set(el, va_arg(va, char *));
00154                 break;
00155 
00156         case EL_EDITOR:
00157                 rv = map_set_editor(el, va_arg(va, char *));
00158                 break;
00159 
00160         case EL_SIGNAL:
00161                 if (va_arg(va, int))
00162                         el->el_flags |= HANDLE_SIGNALS;
00163                 else
00164                         el->el_flags &= ~HANDLE_SIGNALS;
00165                 break;
00166 
00167         case EL_BIND:
00168         case EL_TELLTC:
00169         case EL_SETTC:
00170         case EL_ECHOTC:
00171         case EL_SETTY:
00172         {
00173                 const char *argv[20];
00174                 int i;
00175 
00176                 for (i = 1; i < 20; i++)
00177                         if ((argv[i] = va_arg(va, char *)) == NULL)
00178                                 break;
00179 
00180                 switch (op) {
00181                 case EL_BIND:
00182                         argv[0] = "bind";
00183                         rv = map_bind(el, i, argv);
00184                         break;
00185 
00186                 case EL_TELLTC:
00187                         argv[0] = "telltc";
00188                         rv = term_telltc(el, i, argv);
00189                         break;
00190 
00191                 case EL_SETTC:
00192                         argv[0] = "settc";
00193                         rv = term_settc(el, i, argv);
00194                         break;
00195 
00196                 case EL_ECHOTC:
00197                         argv[0] = "echotc";
00198                         rv = term_echotc(el, i, argv);
00199                         break;
00200 
00201                 case EL_SETTY:
00202                         argv[0] = "setty";
00203                         rv = tty_stty(el, i, argv);
00204                         break;
00205 
00206                 default:
00207                         rv = -1;
00208                         EL_ABORT((el->el_errfile, "Bad op %d\n", op));
00209                         break;
00210                 }
00211                 break;
00212         }
00213 
00214         case EL_ADDFN:
00215         {
00216                 char *name = va_arg(va, char *);
00217                 char *help = va_arg(va, char *);
00218                 el_func_t func = va_arg(va, el_func_t);
00219 
00220                 rv = map_addfunc(el, name, help, func);
00221                 break;
00222         }
00223 
00224         case EL_HIST:
00225         {
00226                 hist_fun_t func = va_arg(va, hist_fun_t);
00227                 ptr_t ptr = va_arg(va, char *);
00228 
00229                 rv = hist_set(el, func, ptr);
00230                 break;
00231         }
00232 
00233         case EL_EDITMODE:
00234                 if (va_arg(va, int))
00235                         el->el_flags &= ~EDIT_DISABLED;
00236                 else
00237                         el->el_flags |= EDIT_DISABLED;
00238                 rv = 0;
00239                 break;
00240 
00241         case EL_GETCFN:
00242         {
00243                 el_rfunc_t rc = va_arg(va, el_rfunc_t);
00244                 rv = el_read_setfn(el, rc);
00245                 break;
00246         }
00247 
00248         case EL_CLIENTDATA:
00249                 el->el_data = va_arg(va, void *);
00250                 break;
00251 
00252         case EL_UNBUFFERED:
00253                 rv = va_arg(va, int);
00254                 if (rv && !(el->el_flags & UNBUFFERED)) {
00255                         el->el_flags |= UNBUFFERED;
00256                         read_prepare(el);
00257                 } else if (!rv && (el->el_flags & UNBUFFERED)) {
00258                         el->el_flags &= ~UNBUFFERED;
00259                         read_finish(el);
00260                 }
00261                 rv = 0;
00262                 break;
00263 
00264         case EL_PREP_TERM:
00265                 rv = va_arg(va, int);
00266                 if (rv)
00267                         (void) tty_rawmode(el);
00268                 else
00269                         (void) tty_cookedmode(el);
00270                 rv = 0;
00271                 break;
00272 
00273         default:
00274                 rv = -1;
00275                 break;
00276         }
00277 
00278         va_end(va);
00279         return (rv);
00280 }

Here is the call graph for this function:

Here is the caller graph for this function:

public int el_source	(	EditLine *	el,
		const char *	fname
	)

Definition at line 423 of file el.c.

References el, fgetln, getenv(), issetugid, NULL, parse_line(), path, strlcat, and strlcpy.

Referenced by main(), and rl_read_init_file().

00424 {
00425         FILE *fp;
00426         size_t len;
00427         char *ptr;
00428 
00429         fp = NULL;
00430         if (fname == NULL) {
00431                 static const char elpath[] = "/.editrc";
00432 #ifdef MAXPATHLEN
00433                 char path[MAXPATHLEN];
00434 #else
00435                 char path[4096];
00436 #endif
00437 
00438 #ifdef HAVE_ISSETUGID
00439                 if (issetugid())
00440                         return (-1);
00441 #endif
00442                 if ((ptr = getenv("HOME")) == NULL)
00443                         return (-1);
00444                 if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path))
00445                         return (-1);
00446                 if (strlcat(path, elpath, sizeof(path)) >= sizeof(path))
00447                         return (-1);
00448                 fname = path;
00449         }
00450         if (fp == NULL)
00451                 fp = fopen(fname, "r");
00452         if (fp == NULL)
00453                 return (-1);
00454 
00455         while ((ptr = fgetln(fp, &len)) != NULL) {
00456                 if (len > 0 && ptr[len - 1] == '\n')
00457                         --len;
00458                 ptr[len] = '\0';
00459                 if (parse_line(el, ptr) == -1) {
00460                         (void) fclose(fp);
00461                         return (-1);
00462                 }
00463         }
00464 
00465         (void) fclose(fp);
00466         return (0);
00467 }

Here is the call graph for this function:

Here is the caller graph for this function:

Generated on Sat Sep 9 01:02:42 2006 for MySQL 5.1 by

1.4.7

mysql/src/5.1-dbg/cmd-line-utils/libedit/el.c File Reference

Functions

Function Documentation