Annotation of embedaddon/readline/examples/rlfe/rlfe.c, revision 1.1.1.1
1.1 misho 1: /* A front-end using readline to "cook" input lines.
2: *
3: * Copyright (C) 2004, 1999 Per Bothner
4: *
5: * This front-end program is free software; you can redistribute it and/or
6: * modify it under the terms of the GNU General Public License as published
7: * by the Free Software Foundation; either version 2, or (at your option)
8: * any later version.
9: *
10: * Some code from Johnson & Troan: "Linux Application Development"
11: * (Addison-Wesley, 1998) was used directly or for inspiration.
12: *
13: * 2003-11-07 Wolfgang Taeuber <wolfgang_taeuber@agilent.com>
14: * Specify a history file and the size of the history file with command
15: * line options; use EDITOR/VISUAL to set vi/emacs preference.
16: */
17:
18: /* PROBLEMS/TODO:
19: *
20: * Only tested under GNU/Linux and Mac OS 10.x; needs to be ported.
21: *
22: * Switching between line-editing-mode vs raw-char-mode depending on
23: * what tcgetattr returns is inherently not robust, plus it doesn't
24: * work when ssh/telnetting in. A better solution is possible if the
25: * tty system can send in-line escape sequences indicating the current
26: * mode, echo'd input, etc. That would also allow a user preference
27: * to set different colors for prompt, input, stdout, and stderr.
28: *
29: * When running mc -c under the Linux console, mc does not recognize
30: * mouse clicks, which mc does when not running under rlfe.
31: *
32: * Pasting selected text containing tabs is like hitting the tab character,
33: * which invokes readline completion. We don't want this. I don't know
34: * if this is fixable without integrating rlfe into a terminal emulator.
35: *
36: * Echo suppression is a kludge, but can only be avoided with better kernel
37: * support: We need a tty mode to disable "real" echoing, while still
38: * letting the inferior think its tty driver to doing echoing.
39: * Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE.
40: *
41: * The latest readline may have some hooks we can use to avoid having
42: * to back up the prompt. (See HAVE_ALREADY_PROMPTED.)
43: *
44: * Desirable readline feature: When in cooked no-echo mode (e.g. password),
45: * echo characters are they are types with '*', but remove them when done.
46: *
47: * Asynchronous output while we're editing an input line should be
48: * inserted in the output view *before* the input line, so that the
49: * lines being edited (with the prompt) float at the end of the input.
50: *
51: * A "page mode" option to emulate more/less behavior: At each page of
52: * output, pause for a user command. This required parsing the output
53: * to keep track of line lengths. It also requires remembering the
54: * output, if we want an option to scroll back, which suggests that
55: * this should be integrated with a terminal emulator like xterm.
56: */
57:
58: #include <stdio.h>
59: #include <fcntl.h>
60: #include <sys/types.h>
61: #include <sys/socket.h>
62: #include <netinet/in.h>
63: #include <arpa/inet.h>
64: #include <signal.h>
65: #include <netdb.h>
66: #include <stdlib.h>
67: #include <errno.h>
68: #include <grp.h>
69: #include <string.h>
70: #include <sys/stat.h>
71: #include <unistd.h>
72: #include <sys/ioctl.h>
73: #include <termios.h>
74:
75: #include "config.h"
76: #include "extern.h"
77:
78: #if defined (HAVE_SYS_WAIT_H)
79: # include <sys/wait.h>
80: #endif
81:
82: #ifdef READLINE_LIBRARY
83: # include "readline.h"
84: # include "history.h"
85: #else
86: # include <readline/readline.h>
87: # include <readline/history.h>
88: #endif
89:
90: #ifndef COMMAND
91: #define COMMAND "/bin/bash"
92: #endif
93: #ifndef COMMAND_ARGS
94: #define COMMAND_ARGS COMMAND
95: #endif
96:
97: #ifndef ALT_COMMAND
98: #define ALT_COMMAND "/bin/sh"
99: #endif
100: #ifndef ALT_COMMAND_ARGS
101: #define ALT_COMMAND_ARGS ALT_COMMAND
102: #endif
103:
104: #ifndef HAVE_MEMMOVE
105: # if __GNUC__ > 1
106: # define memmove(d, s, n) __builtin_memcpy(d, s, n)
107: # else
108: # define memmove(d, s, n) memcpy(d, s, n)
109: # endif
110: #else
111: # define memmove(d, s, n) memcpy(d, s, n)
112: #endif
113:
114: #define APPLICATION_NAME "rlfe"
115:
116: static int in_from_inferior_fd;
117: static int out_to_inferior_fd;
118: static void set_edit_mode ();
119: static void usage_exit ();
120: static char *hist_file = 0;
121: static int hist_size = 0;
122:
123: /* Unfortunately, we cannot safely display echo from the inferior process.
124: The reason is that the echo bit in the pty is "owned" by the inferior,
125: and if we try to turn it off, we could confuse the inferior.
126: Thus, when echoing, we get echo twice: First readline echoes while
127: we're actually editing. Then we send the line to the inferior, and the
128: terminal driver send back an extra echo.
129: The work-around is to remember the input lines, and when we see that
130: line come back, we supress the output.
131: A better solution (supposedly available on SVR4) would be a smarter
132: terminal driver, with more flags ... */
133: #define ECHO_SUPPRESS_MAX 1024
134: char echo_suppress_buffer[ECHO_SUPPRESS_MAX];
135: int echo_suppress_start = 0;
136: int echo_suppress_limit = 0;
137:
138: /*#define DEBUG*/
139:
140: #ifdef DEBUG
141: FILE *logfile = NULL;
142: #define DPRINT0(FMT) (fprintf(logfile, FMT), fflush(logfile))
143: #define DPRINT1(FMT, V1) (fprintf(logfile, FMT, V1), fflush(logfile))
144: #define DPRINT2(FMT, V1, V2) (fprintf(logfile, FMT, V1, V2), fflush(logfile))
145: #else
146: #define DPRINT0(FMT) ((void) 0) /* Do nothing */
147: #define DPRINT1(FMT, V1) ((void) 0) /* Do nothing */
148: #define DPRINT2(FMT, V1, V2) ((void) 0) /* Do nothing */
149: #endif
150:
151: struct termios orig_term;
152:
153: /* Pid of child process. */
154: static pid_t child = -1;
155:
156: static void
157: sig_child (int signo)
158: {
159: int status;
160: wait (&status);
161: if (hist_file != 0)
162: {
163: write_history (hist_file);
164: if (hist_size)
165: history_truncate_file (hist_file, hist_size);
166: }
167: DPRINT0 ("(Child process died.)\n");
168: tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
169: exit (0);
170: }
171:
172: volatile int propagate_sigwinch = 0;
173:
174: /* sigwinch_handler
175: * propagate window size changes from input file descriptor to
176: * master side of pty.
177: */
178: void sigwinch_handler(int signal) {
179: propagate_sigwinch = 1;
180: }
181:
182:
183: /* get_slave_pty() returns an integer file descriptor.
184: * If it returns < 0, an error has occurred.
185: * Otherwise, it has returned the slave file descriptor.
186: */
187:
188: int get_slave_pty(char *name) {
189: struct group *gptr;
190: gid_t gid;
191: int slave = -1;
192:
193: /* chown/chmod the corresponding pty, if possible.
194: * This will only work if the process has root permissions.
195: * Alternatively, write and exec a small setuid program that
196: * does just this.
197: */
198: if ((gptr = getgrnam("tty")) != 0) {
199: gid = gptr->gr_gid;
200: } else {
201: /* if the tty group does not exist, don't change the
202: * group on the slave pty, only the owner
203: */
204: gid = -1;
205: }
206:
207: /* Note that we do not check for errors here. If this is code
208: * where these actions are critical, check for errors!
209: */
210: chown(name, getuid(), gid);
211: /* This code only makes the slave read/writeable for the user.
212: * If this is for an interactive shell that will want to
213: * receive "write" and "wall" messages, OR S_IWGRP into the
214: * second argument below.
215: */
216: chmod(name, S_IRUSR|S_IWUSR);
217:
218: /* open the corresponding slave pty */
219: slave = open(name, O_RDWR);
220: return (slave);
221: }
222:
223: /* Certain special characters, such as ctrl/C, we want to pass directly
224: to the inferior, rather than letting readline handle them. */
225:
226: static char special_chars[20];
227: static int special_chars_count;
228:
229: static void
230: add_special_char(int ch)
231: {
232: if (ch != 0)
233: special_chars[special_chars_count++] = ch;
234: }
235:
236: static int eof_char;
237:
238: static int
239: is_special_char(int ch)
240: {
241: int i;
242: #if 0
243: if (ch == eof_char && rl_point == rl_end)
244: return 1;
245: #endif
246: for (i = special_chars_count; --i >= 0; )
247: if (special_chars[i] == ch)
248: return 1;
249: return 0;
250: }
251:
252: static char buf[1024];
253: /* buf[0 .. buf_count-1] is the what has been emitted on the current line.
254: It is used as the readline prompt. */
255: static int buf_count = 0;
256:
257: int do_emphasize_input = 1;
258: int current_emphasize_input;
259:
260: char *start_input_mode = "\033[1m";
261: char *end_input_mode = "\033[0m";
262:
263: int num_keys = 0;
264:
265: static void maybe_emphasize_input (int on)
266: {
267: if (on == current_emphasize_input
268: || (on && ! do_emphasize_input))
269: return;
270: fprintf (rl_outstream, on ? start_input_mode : end_input_mode);
271: fflush (rl_outstream);
272: current_emphasize_input = on;
273: }
274:
275: static void
276: null_prep_terminal (int meta)
277: {
278: }
279:
280: static void
281: null_deprep_terminal ()
282: {
283: maybe_emphasize_input (0);
284: }
285:
286: static int
287: pre_input_change_mode (void)
288: {
289: return 0;
290: }
291:
292: char pending_special_char;
293:
294: static void
295: line_handler (char *line)
296: {
297: if (line == NULL)
298: {
299: char buf[1];
300: DPRINT0("saw eof!\n");
301: buf[0] = '\004'; /* ctrl/d */
302: write (out_to_inferior_fd, buf, 1);
303: }
304: else
305: {
306: static char enter[] = "\r";
307: /* Send line to inferior: */
308: int length = strlen (line);
309: if (length > ECHO_SUPPRESS_MAX-2)
310: {
311: echo_suppress_start = 0;
312: echo_suppress_limit = 0;
313: }
314: else
315: {
316: if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2)
317: {
318: if (echo_suppress_limit - echo_suppress_start + length
319: <= ECHO_SUPPRESS_MAX - 2)
320: {
321: memmove (echo_suppress_buffer,
322: echo_suppress_buffer + echo_suppress_start,
323: echo_suppress_limit - echo_suppress_start);
324: echo_suppress_limit -= echo_suppress_start;
325: echo_suppress_start = 0;
326: }
327: else
328: {
329: echo_suppress_limit = 0;
330: }
331: echo_suppress_start = 0;
332: }
333: memcpy (echo_suppress_buffer + echo_suppress_limit,
334: line, length);
335: echo_suppress_limit += length;
336: echo_suppress_buffer[echo_suppress_limit++] = '\r';
337: echo_suppress_buffer[echo_suppress_limit++] = '\n';
338: }
339: write (out_to_inferior_fd, line, length);
340: if (pending_special_char == 0)
341: {
342: write (out_to_inferior_fd, enter, sizeof(enter)-1);
343: if (*line)
344: add_history (line);
345: }
346: free (line);
347: }
348: rl_callback_handler_remove ();
349: buf_count = 0;
350: num_keys = 0;
351: if (pending_special_char != 0)
352: {
353: write (out_to_inferior_fd, &pending_special_char, 1);
354: pending_special_char = 0;
355: }
356: }
357:
358: /* Value of rl_getc_function.
359: Use this because readline should read from stdin, not rl_instream,
360: points to the pty (so readline has monitor its terminal modes). */
361:
362: int
363: my_rl_getc (FILE *dummy)
364: {
365: int ch = rl_getc (stdin);
366: if (is_special_char (ch))
367: {
368: pending_special_char = ch;
369: return '\r';
370: }
371: return ch;
372: }
373:
374: int
375: main(int argc, char** argv)
376: {
377: char *path;
378: int i;
379: int master;
380: char *name;
381: int in_from_tty_fd;
382: struct sigaction act;
383: struct winsize ws;
384: struct termios t;
385: int maxfd;
386: fd_set in_set;
387: static char empty_string[1] = "";
388: char *prompt = empty_string;
389: int ioctl_err = 0;
390: int arg_base = 1;
391:
392: #ifdef DEBUG
393: logfile = fopen("/tmp/rlfe.log", "w");
394: #endif
395:
396: while (arg_base<argc)
397: {
398: if (argv[arg_base][0] != '-')
399: break;
400: if (arg_base+1 >= argc )
401: usage_exit();
402: switch(argv[arg_base][1])
403: {
404: case 'h':
405: arg_base++;
406: hist_file = argv[arg_base];
407: break;
408: case 's':
409: arg_base++;
410: hist_size = atoi(argv[arg_base]);
411: if (hist_size<0)
412: usage_exit();
413: break;
414: default:
415: usage_exit();
416: }
417: arg_base++;
418: }
419: if (hist_file)
420: read_history (hist_file);
421:
422: set_edit_mode ();
423:
424: rl_readline_name = APPLICATION_NAME;
425:
426: if ((master = OpenPTY (&name)) < 0)
427: {
428: perror("ptypair: could not open master pty");
429: exit(1);
430: }
431:
432: DPRINT1("pty name: '%s'\n", name);
433:
434: /* set up SIGWINCH handler */
435: act.sa_handler = sigwinch_handler;
436: sigemptyset(&(act.sa_mask));
437: act.sa_flags = 0;
438: if (sigaction(SIGWINCH, &act, NULL) < 0)
439: {
440: perror("ptypair: could not handle SIGWINCH ");
441: exit(1);
442: }
443:
444: if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
445: {
446: perror("ptypair: could not get window size");
447: exit(1);
448: }
449:
450: if ((child = fork()) < 0)
451: {
452: perror("cannot fork");
453: exit(1);
454: }
455:
456: if (child == 0)
457: {
458: int slave; /* file descriptor for slave pty */
459:
460: /* We are in the child process */
461: close(master);
462:
463: #ifdef TIOCSCTTY
464: if ((slave = get_slave_pty(name)) < 0)
465: {
466: perror("ptypair: could not open slave pty");
467: exit(1);
468: }
469: #endif
470:
471: /* We need to make this process a session group leader, because
472: * it is on a new PTY, and things like job control simply will
473: * not work correctly unless there is a session group leader
474: * and process group leader (which a session group leader
475: * automatically is). This also disassociates us from our old
476: * controlling tty.
477: */
478: if (setsid() < 0)
479: {
480: perror("could not set session leader");
481: }
482:
483: /* Tie us to our new controlling tty. */
484: #ifdef TIOCSCTTY
485: if (ioctl(slave, TIOCSCTTY, NULL))
486: {
487: perror("could not set new controlling tty");
488: }
489: #else
490: if ((slave = get_slave_pty(name)) < 0)
491: {
492: perror("ptypair: could not open slave pty");
493: exit(1);
494: }
495: #endif
496:
497: /* make slave pty be standard in, out, and error */
498: dup2(slave, STDIN_FILENO);
499: dup2(slave, STDOUT_FILENO);
500: dup2(slave, STDERR_FILENO);
501:
502: /* at this point the slave pty should be standard input */
503: if (slave > 2)
504: {
505: close(slave);
506: }
507:
508: /* Try to restore window size; failure isn't critical */
509: if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0)
510: {
511: perror("could not restore window size");
512: }
513:
514: /* now start the shell */
515: {
516: static char* command_args[] = { COMMAND_ARGS, NULL };
517: static char* alt_command_args[] = { ALT_COMMAND_ARGS, NULL };
518: if (argc <= 1)
519: {
520: execvp (COMMAND, command_args);
521: execvp (ALT_COMMAND, alt_command_args);
522: }
523: else
524: execvp (argv[arg_base], &argv[arg_base]);
525: }
526:
527: /* should never be reached */
528: exit(1);
529: }
530:
531: /* parent */
532: signal (SIGCHLD, sig_child);
533:
534: /* Note that we only set termios settings for standard input;
535: * the master side of a pty is NOT a tty.
536: */
537: tcgetattr(STDIN_FILENO, &orig_term);
538:
539: t = orig_term;
540: eof_char = t.c_cc[VEOF];
541: /* add_special_char(t.c_cc[VEOF]);*/
542: add_special_char(t.c_cc[VINTR]);
543: add_special_char(t.c_cc[VQUIT]);
544: add_special_char(t.c_cc[VSUSP]);
545: #if defined (VDISCARD)
546: add_special_char(t.c_cc[VDISCARD]);
547: #endif
548:
549: t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \
550: ECHOK | ECHONL
551: #if defined (ECHOKE)
552: | ECHOKE
553: #endif
554: #if defined (ECHOPRT)
555: | ECHOPRT
556: #endif
557: );
558: t.c_iflag &= ~ICRNL;
559: t.c_iflag |= IGNBRK;
560: t.c_cc[VMIN] = 1;
561: t.c_cc[VTIME] = 0;
562: tcsetattr(STDIN_FILENO, TCSANOW, &t);
563: in_from_inferior_fd = master;
564: out_to_inferior_fd = master;
565: rl_instream = fdopen (master, "r");
566: rl_getc_function = my_rl_getc;
567:
568: rl_prep_term_function = null_prep_terminal;
569: rl_deprep_term_function = null_deprep_terminal;
570: rl_pre_input_hook = pre_input_change_mode;
571: rl_callback_handler_install (prompt, line_handler);
572:
573: in_from_tty_fd = STDIN_FILENO;
574: FD_ZERO (&in_set);
575: maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd
576: : in_from_tty_fd;
577: for (;;)
578: {
579: int num;
580: FD_SET (in_from_inferior_fd, &in_set);
581: FD_SET (in_from_tty_fd, &in_set);
582:
583: num = select(maxfd+1, &in_set, NULL, NULL, NULL);
584:
585: if (propagate_sigwinch)
586: {
587: struct winsize ws;
588: if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
589: {
590: ioctl (master, TIOCSWINSZ, &ws);
591: }
592: propagate_sigwinch = 0;
593: continue;
594: }
595:
596: if (num <= 0)
597: {
598: perror ("select");
599: exit (-1);
600: }
601: if (FD_ISSET (in_from_tty_fd, &in_set))
602: {
603: extern int _rl_echoing_p;
604: struct termios term_master;
605: int do_canon = 1;
606: int do_icrnl = 1;
607: int ioctl_ret;
608:
609: DPRINT1("[tty avail num_keys:%d]\n", num_keys);
610:
611: /* If we can't get tty modes for the master side of the pty, we
612: can't handle non-canonical-mode programs. Always assume the
613: master is in canonical echo mode if we can't tell. */
614: ioctl_ret = tcgetattr(master, &term_master);
615:
616: if (ioctl_ret >= 0)
617: {
618: do_canon = (term_master.c_lflag & ICANON) != 0;
619: do_icrnl = (term_master.c_lflag & ICRNL) != 0;
620: _rl_echoing_p = (term_master.c_lflag & ECHO) != 0;
621: DPRINT1 ("echo,canon,crnl:%03d\n",
622: 100 * _rl_echoing_p
623: + 10 * do_canon
624: + 1 * do_icrnl);
625: }
626: else
627: {
628: if (ioctl_err == 0)
629: DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno);
630: ioctl_err = 1;
631: }
632:
633: if (do_canon == 0 && num_keys == 0)
634: {
635: char ch[10];
636: int count = read (STDIN_FILENO, ch, sizeof(ch));
637: DPRINT1("[read %d chars from stdin: ", count);
638: DPRINT2(" \"%.*s\"]\n", count, ch);
639: if (do_icrnl)
640: {
641: int i = count;
642: while (--i >= 0)
643: {
644: if (ch[i] == '\r')
645: ch[i] = '\n';
646: }
647: }
648: maybe_emphasize_input (1);
649: write (out_to_inferior_fd, ch, count);
650: }
651: else
652: {
653: if (num_keys == 0)
654: {
655: int i;
656: /* Re-install callback handler for new prompt. */
657: if (prompt != empty_string)
658: free (prompt);
659: if (prompt == NULL)
660: {
661: DPRINT0("New empty prompt\n");
662: prompt = empty_string;
663: }
664: else
665: {
666: if (do_emphasize_input && buf_count > 0)
667: {
668: prompt = malloc (buf_count + strlen (end_input_mode)
669: + strlen (start_input_mode) + 5);
670: sprintf (prompt, "\001%s\002%.*s\001%s\002",
671: end_input_mode,
672: buf_count, buf,
673: start_input_mode);
674: }
675: else
676: {
677: prompt = malloc (buf_count + 1);
678: memcpy (prompt, buf, buf_count);
679: prompt[buf_count] = '\0';
680: }
681: DPRINT1("New prompt '%s'\n", prompt);
682: #if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED */
683: /* Doesn't quite work when do_emphasize_input is 1. */
684: rl_already_prompted = buf_count > 0;
685: #else
686: if (buf_count > 0)
687: write (1, "\r", 1);
688: #endif
689: }
690:
691: rl_callback_handler_install (prompt, line_handler);
692: }
693: num_keys++;
694: maybe_emphasize_input (1);
695: rl_callback_read_char ();
696: }
697: }
698: else /* output from inferior. */
699: {
700: int i;
701: int count;
702: int old_count;
703: if (buf_count > (sizeof(buf) >> 2))
704: buf_count = 0;
705: count = read (in_from_inferior_fd, buf+buf_count,
706: sizeof(buf) - buf_count);
707: DPRINT2("read %d from inferior, buf_count=%d", count, buf_count);
708: DPRINT2(": \"%.*s\"", count, buf+buf_count);
709: maybe_emphasize_input (0);
710: if (count <= 0)
711: {
712: DPRINT0 ("(Connection closed by foreign host.)\n");
713: tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
714: exit (0);
715: }
716: old_count = buf_count;
717:
718: /* Look for any pending echo that we need to suppress. */
719: while (echo_suppress_start < echo_suppress_limit
720: && count > 0
721: && buf[buf_count] == echo_suppress_buffer[echo_suppress_start])
722: {
723: count--;
724: buf_count++;
725: echo_suppress_start++;
726: }
727: DPRINT1("suppressed %d characters of echo.\n", buf_count-old_count);
728:
729: /* Write to the terminal anything that was not suppressed. */
730: if (count > 0)
731: write (1, buf + buf_count, count);
732:
733: /* Finally, look for a prompt candidate.
734: * When we get around to going input (from the keyboard),
735: * we will consider the prompt to be anything since the last
736: * line terminator. So we need to save that text in the
737: * initial part of buf. However, anything before the
738: * most recent end-of-line is not interesting. */
739: buf_count += count;
740: #if 1
741: for (i = buf_count; --i >= old_count; )
742: #else
743: for (i = buf_count - 1; i-- >= buf_count - count; )
744: #endif
745: {
746: if (buf[i] == '\n' || buf[i] == '\r')
747: {
748: i++;
749: memmove (buf, buf+i, buf_count - i);
750: buf_count -= i;
751: break;
752: }
753: }
754: DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count);
755: }
756: }
757: }
758:
759: static void set_edit_mode ()
760: {
761: int vi = 0;
762: char *shellopts;
763:
764: shellopts = getenv ("SHELLOPTS");
765: while (shellopts != 0)
766: {
767: if (strncmp ("vi", shellopts, 2) == 0)
768: {
769: vi = 1;
770: break;
771: }
772: shellopts = strchr (shellopts + 1, ':');
773: }
774:
775: if (!vi)
776: {
777: if (getenv ("EDITOR") != 0)
778: vi |= strcmp (getenv ("EDITOR"), "vi") == 0;
779: }
780:
781: if (vi)
782: rl_variable_bind ("editing-mode", "vi");
783: else
784: rl_variable_bind ("editing-mode", "emacs");
785: }
786:
787:
788: static void usage_exit ()
789: {
790: fprintf (stderr, "Usage: rlfe [-h histfile] [-s size] cmd [arg1] [arg2] ...\n\n");
791: exit (1);
792: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rlfe.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 / examples / rlfe