1847 lines
56 KiB
C
1847 lines
56 KiB
C
/*
|
|
* Copyright (C) 1991, 1992 by Chris Thewalt (thewalt@ce.berkeley.edu)
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software
|
|
* for any purpose and without fee is hereby granted, provided
|
|
* that the above copyright notices appear in all copies and that both the
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation. This software is provided "as is" without express or
|
|
* implied warranty.
|
|
*/
|
|
/*
|
|
*************************** Motivation **********************************
|
|
|
|
Many interactive programs read input line by line, but would like to
|
|
provide line editing and history functionality to the end-user that
|
|
runs the program.
|
|
|
|
The input-edit package provides that functionality. As far as the
|
|
programmer is concerned, the program only asks for the next line
|
|
of input. However, until the user presses the RETURN key they can use
|
|
emacs-style line editing commands and can traverse the history of lines
|
|
previously typed.
|
|
|
|
Other packages, such as GNU's readline, have greater capability but are
|
|
also substantially larger. Input-edit is small, since it uses neither
|
|
stdio nor any termcap features, and is also quite portable. It only uses
|
|
\b to backspace and \007 to ring the bell on errors. Since it cannot
|
|
edit multiple lines it scrolls long lines left and right on the same line.
|
|
|
|
Input edit uses classic (not ANSI) C, and should run on any Unix
|
|
system (BSD or SYSV), PC's with the MSC compiler, or Vax/VMS (untested by me).
|
|
Porting the package to new systems basicaly requires code to read a
|
|
character when it is typed without echoing it, everything else should be OK.
|
|
|
|
I have run the package on:
|
|
|
|
DECstation 5000, Ultrix 4.2 with cc and gcc
|
|
Sun Sparc 2, SunOS 4.1.1, with cc
|
|
SGI Iris, IRIX System V.3, with cc
|
|
PC, DRDOS 5.0, with MSC 6.0
|
|
|
|
The description below is broken into two parts, the end-user (editing)
|
|
interface and the programmer interface. Send bug reports, fixes and
|
|
enhancements to:
|
|
|
|
Chris Thewalt (thewalt@ce.berkeley.edu)
|
|
2/4/92
|
|
|
|
PS: I don't have, and don't want to add, a vi mode, sorry.
|
|
|
|
************************** End-User Interface ***************************
|
|
|
|
Entering printable keys generally inserts new text into the buffer (unless
|
|
in overwrite mode, see below). Other special keys can be used to modify
|
|
the text in the buffer. In the description of the keys below, ^n means
|
|
Control-n, or holding the CONTROL key down while pressing "n". M-B means
|
|
Meta-B (or Alt-B). Errors will ring the terminal bell.
|
|
|
|
^A/^E : Move cursor to beginning/end of the line.
|
|
^F/^B : Move cursor forward/backward one character.
|
|
^D : Delete the character under the cursor.
|
|
^H, DEL : Delete the character to the left of the cursor.
|
|
^K : Kill from the cursor to the end of line.
|
|
^L : Redraw current line.
|
|
^O : Toggle overwrite/insert mode. Initially in insert mode. Text
|
|
added in overwrite mode (including yanks) overwrite
|
|
existing text, while insert mode does not overwrite.
|
|
^P/^N : Move to previous/next item on history list.
|
|
^R/^S : Perform incremental reverse/forward search for string on
|
|
the history list. Typing normal characters adds to the current
|
|
search string and searches for a match. Typing ^R/^S marks
|
|
the start of a new search, and moves on to the next match.
|
|
Typing ^H or DEL deletes the last character from the search
|
|
string, and searches from the starting location of the last search.
|
|
Therefore, repeated DEL's appear to unwind to the match nearest
|
|
the point at which the last ^R or ^S was typed. If DEL is
|
|
repeated until the search string is empty the search location
|
|
begins from the start of the history list. Typing ESC or
|
|
any other editing character accepts the current match and
|
|
loads it into the buffer, terminating the search.
|
|
^T : Toggle the characters under and to the left of the cursor.
|
|
^U : Kill from beginning to the end of the line.
|
|
^Y : Yank previously killed text back at current location. Note that
|
|
this will overwrite or insert, depending on the current mode.
|
|
M-F/M-B : Move cursor forward/backward one word.
|
|
M-D : Delete the word under the cursor.
|
|
^SPC : Set mark.
|
|
^W : Kill from mark to point.
|
|
^X : Exchange mark and point.
|
|
TAB : By default adds spaces to buffer to get to next TAB stop
|
|
(just after every 8th column), although this may be rebound by the
|
|
programmer, as described below.
|
|
NL, CR : returns current buffer to the program.
|
|
|
|
DOS and ANSI terminal arrow key sequences are recognized, and act like:
|
|
|
|
up : same as ^P
|
|
down : same as ^N
|
|
left : same as ^B
|
|
right : same as ^F
|
|
|
|
************************** Programmer Interface ***************************
|
|
|
|
The programmer accesses input-edit through five functions, and optionally
|
|
through three additional function pointer hooks. The five functions are:
|
|
|
|
char *Getline(char *prompt)
|
|
|
|
Prints the prompt and allows the user to edit the current line. A
|
|
pointer to the line is returned when the user finishes by
|
|
typing a newline or a return. Unlike GNU readline, the returned
|
|
pointer points to a static buffer, so it should not be free'd, and
|
|
the buffer contains the newline character. The user enters an
|
|
end-of-file by typing ^D on an empty line, in which case the
|
|
first character of the returned buffer is '\0'. Getline never
|
|
returns a NULL pointer. The getline function sets terminal modes
|
|
needed to make it work, and resets them before returning to the
|
|
caller. The getline function also looks for characters that would
|
|
generate a signal, and resets the terminal modes before raising the
|
|
signal condition. If the signal handler returns to getline,
|
|
the screen is automatically redrawn and editing can continue.
|
|
Getline now requires both the input and output stream be connected
|
|
to the terminal (not redirected) so the main program should check
|
|
to make sure this is true. If input or output have been redirected
|
|
the main program should use buffered IO (stdio) rather than
|
|
the slow 1 character read()s that getline uses (note: this limitation
|
|
has been removed).
|
|
|
|
char *Getlinem(int mode, char *prompt)
|
|
|
|
mode: -1 = init, 0 = line mode, 1 = one char at a time mode, 2 = cleanup
|
|
|
|
More specialized version of the previous function. Depending on
|
|
the mode, it behaves differently. Its main use is to allow
|
|
character by character input from the input stream (useful when
|
|
in an X eventloop). It will return NULL as long as no newline
|
|
has been received. Its use is typically as follows:
|
|
1) In the program initialization part one calls: Getlinem(-1,"prompt>")
|
|
2) In the X inputhandler: if ((line = Getlinem(1,NULL))) {
|
|
3) In the termination routine: Getlinem(2,NULL)
|
|
With mode=0 the function behaves exactly like the previous function.
|
|
|
|
void Gl_config(const char *which, int value)
|
|
|
|
Set some config options. Which can be:
|
|
"noecho": do not echo characters (used for passwd input)
|
|
"erase": do erase line after return (used for text scrollers)
|
|
|
|
void Gl_setwidth(int width)
|
|
|
|
Set the width of the terminal to the specified width. The default
|
|
width is 80 characters, so this function need only be called if the
|
|
width of the terminal is not 80. Since horizontal scrolling is
|
|
controlled by this parameter it is important to get it right.
|
|
|
|
void Gl_histinit(char *file)
|
|
|
|
This function reads a history list from file. So lines from a
|
|
previous session can be used again.
|
|
|
|
void Gl_histadd(char *buf)
|
|
|
|
The Gl_histadd function checks to see if the buf is not empty or
|
|
whitespace, and also checks to make sure it is different than
|
|
the last saved buffer to avoid repeats on the history list.
|
|
If the buf is a new non-blank string a copy is made and saved on
|
|
the history list, so the caller can re-use the specified buf.
|
|
|
|
The main loop in testgl.c, included in this directory, shows how the
|
|
input-edit package can be used:
|
|
|
|
extern char *Getline();
|
|
extern void Gl_histadd();
|
|
main()
|
|
{
|
|
char *p;
|
|
Gl_histinit(".hist");
|
|
do {
|
|
p = Getline("PROMPT>>>> ");
|
|
Gl_histadd(p);
|
|
fputs(p, stdout);
|
|
} while (*p != 0);
|
|
}
|
|
|
|
In order to allow the main program to have additional access to the buffer,
|
|
to implement things such as completion or auto-indent modes, three
|
|
function pointers can be bound to user functions to modify the buffer as
|
|
described below. By default gl_in_hook and gl_out_hook are set to NULL,
|
|
and gl_tab_hook is bound to a function that inserts spaces until the next
|
|
logical tab stop is reached. The user can reassign any of these pointers
|
|
to other functions. Each of the functions bound to these hooks receives
|
|
the current buffer as the first argument, and must return the location of
|
|
the leftmost change made in the buffer. If the buffer isn't modified the
|
|
functions should return -1. When the hook function returns the screen is
|
|
updated to reflect any changes made by the user function.
|
|
|
|
int (*gl_in_hook)(char *buf)
|
|
|
|
If gl_in_hook is non-NULL the function is called each time a new
|
|
buffer is loaded. It is called when getline is entered, with an
|
|
empty buffer, it is called each time a new buffer is loaded from
|
|
the history with ^P or ^N, and it is called when an incremental
|
|
search string is accepted (when the search is terminated). The
|
|
buffer can be modified and will be redrawn upon return to Getline().
|
|
|
|
int (*gl_out_hook)(char *buf)
|
|
|
|
If gl_out_hook is non-NULL it is called when a line has been
|
|
completed by the user entering a newline or return. The buffer
|
|
handed to the hook does not yet have the newline appended. If the
|
|
buffer is modified the screen is redrawn before getline returns the
|
|
buffer to the caller.
|
|
|
|
int (*gl_tab_hook)(char *buf, int prompt_width, int *cursor_loc)
|
|
|
|
If gl_tab_hook is non-NULL, it is called whenever a tab is typed.
|
|
In addition to receiving the buffer, the current prompt width is
|
|
given (needed to do tabbing right) and a pointer to the cursor
|
|
offset is given, where a 0 offset means the first character in the
|
|
line. Not only does the cursor_loc tell the programmer where the
|
|
TAB was received, but it can be reset so that the cursor will end
|
|
up at the specified location after the screen is redrawn.
|
|
*/
|
|
|
|
/* forward reference needed for gl_tab_hook */
|
|
static int gl_tab(char *buf, int offset, int *loc);
|
|
|
|
/********************* exported interface ********************************/
|
|
|
|
static int (*gl_in_hook)(char *buf) = 0;
|
|
static int (*gl_out_hook)(char *buf) = 0;
|
|
static int (*gl_tab_hook)(char *buf, int prompt_width, int *loc) = gl_tab;
|
|
|
|
/******************** imported interface *********************************/
|
|
|
|
#include "sigar_getline.h"
|
|
#include "sigar_private.h"
|
|
#include "sigar_util.h"
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
/******************** internal interface *********************************/
|
|
|
|
static char *sigar_getlinem(int mode, char *prompt); /* allows reading char by char */
|
|
|
|
static void sigar_getline_config(const char *which, int value); /* set some options */
|
|
|
|
static void sigar_getline_clear_screen(void);
|
|
|
|
#define BUF_SIZE 8096
|
|
|
|
static int gl_init_done = -1; /* terminal mode flag */
|
|
static int gl_notty = 0; /* 1 when not a tty */
|
|
static int gl_eof = 0; /* 1 when not a tty and read() == -1 */
|
|
static int gl_termw = 80; /* actual terminal width */
|
|
static int gl_scroll = 27; /* width of EOL scrolling region */
|
|
static int gl_width = 0; /* net size available for input */
|
|
static int gl_extent = 0; /* how far to redraw, 0 means all */
|
|
static int gl_overwrite = 0; /* overwrite mode */
|
|
static int gl_no_echo = 0; /* do not echo input characters */
|
|
static int gl_passwd = 0; /* do not echo input characters */
|
|
static int gl_erase_line = 0; /* erase line before returning */
|
|
static int gl_pos, gl_cnt = 0; /* position and size of input */
|
|
static char gl_buf[BUF_SIZE]; /* input buffer */
|
|
static char gl_killbuf[BUF_SIZE]=""; /* killed text */
|
|
static char *gl_prompt; /* to save the prompt string */
|
|
static char gl_intrc = 0; /* keyboard SIGINT char */
|
|
static char gl_quitc = 0; /* keyboard SIGQUIT char */
|
|
static char gl_suspc = 0; /* keyboard SIGTSTP char */
|
|
static char gl_dsuspc = 0; /* delayed SIGTSTP char */
|
|
static int gl_search_mode = 0; /* search mode flag */
|
|
static int gl_bell_enabled = 0; /* bell mode */
|
|
static int gl_savehist = 0; /* # of lines to save in hist file */
|
|
static char gl_histfile[256]; /* name of history file */
|
|
|
|
static void gl_init(); /* prepare to edit a line */
|
|
static void gl_bell(); /* ring bell */
|
|
static void gl_cleanup(); /* to undo gl_init */
|
|
static void gl_char_init(); /* get ready for no echo input */
|
|
static void gl_char_cleanup(); /* undo gl_char_init */
|
|
|
|
static void gl_addchar(int c); /* install specified char */
|
|
static void gl_del(int loc); /* del, either left (-1) or cur (0) */
|
|
static void gl_error(char *buf); /* write error msg and die */
|
|
static void gl_fixup(char *p, int c, int cur); /* fixup state variables and screen */
|
|
static int gl_getc(); /* read one char from terminal */
|
|
static void gl_kill(); /* delete to EOL */
|
|
static void gl_newline(); /* handle \n or \r */
|
|
static void gl_putc(int c); /* write one char to terminal */
|
|
static void gl_puts(char *buf); /* write a line to terminal */
|
|
static void gl_transpose(); /* transpose two chars */
|
|
static void gl_yank(); /* yank killed text */
|
|
|
|
static int is_whitespace(char c); /* "whitespace" very loosely interpreted */
|
|
static void gl_back_1_word(); /* move cursor back one word */
|
|
static void gl_kill_1_word(); /* kill to end of word */
|
|
static void gl_kill_region(int i, int j); /* kills from i to j */
|
|
static void gl_fwd_1_word(); /* move cursor forward one word */
|
|
static void gl_set_mark(); /* sets mark to be at point */
|
|
static void gl_exch(); /* exchanges point and mark */
|
|
static void gl_wipe(); /* kills from mark to point */
|
|
static int gl_mark = -1; /* position of mark. gl_mark<0 if not set */
|
|
|
|
static void hist_init(); /* initializes hist pointers */
|
|
static char *hist_next(); /* return ptr to next item */
|
|
static char *hist_prev(); /* return ptr to prev item */
|
|
static char *hist_save(char *p); /* makes copy of a string, without NL */
|
|
|
|
static void search_addchar(int c); /* increment search string */
|
|
static void search_term(); /* reset with current contents */
|
|
static void search_back(int s); /* look back for current string */
|
|
static void search_forw(int s); /* look forw for current string */
|
|
|
|
/************************ nonportable part *********************************/
|
|
|
|
#ifdef MSDOS
|
|
#include <bios.h>
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
# define MSDOS
|
|
# include <io.h>
|
|
# include <windows.h>
|
|
#endif /* WIN32 */
|
|
|
|
#ifdef __MWERKS__
|
|
#define R__MWERKS
|
|
#endif
|
|
|
|
#ifdef R__MWERKS
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
#if defined(_AIX) || defined(__Lynx__) || defined(__APPLE__)
|
|
#define unix
|
|
#endif
|
|
|
|
#if defined(__hpux) || defined(__osf__) /* W.Karig@gsi.de */
|
|
#ifndef unix
|
|
#define unix
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef unix
|
|
#include <unistd.h>
|
|
#if !defined(__osf__) && !defined(_AIX) /* W.Karig@gsi.de */
|
|
#include <sys/ioctl.h>
|
|
#endif
|
|
|
|
#if defined(__linux__) && defined(__powerpc__)
|
|
# define R__MKLINUX // = linux on PowerMac
|
|
#endif
|
|
#if defined(__linux__) && defined(__alpha__)
|
|
# define R__ALPHALINUX // = linux on Alpha
|
|
#endif
|
|
|
|
#if defined(TIOCGETP) && !defined(__sgi) && !defined(R__MKLINUX) && \
|
|
!defined(R__ALPHALINUX) /* use BSD interface if possible */
|
|
#include <sgtty.h>
|
|
static struct sgttyb new_tty, old_tty;
|
|
static struct tchars tch;
|
|
static struct ltchars ltch;
|
|
#else
|
|
#ifdef SIGTSTP /* need POSIX interface to handle SUSP */
|
|
#include <termios.h>
|
|
#if defined(__sun) || defined(__sgi) || defined(R__MKLINUX) || \
|
|
defined(R__ALPHALINUX)
|
|
#undef TIOCGETP /* Solaris and SGI define TIOCGETP in <termios.h> */
|
|
#undef TIOCSETP
|
|
#endif
|
|
static struct termios new_termios, old_termios;
|
|
#else /* use SYSV interface */
|
|
#include <termio.h>
|
|
static struct termio new_termio, old_termio;
|
|
#endif
|
|
#endif
|
|
#endif /* unix */
|
|
|
|
#ifdef VMS
|
|
#include <descrip.h>
|
|
#include <ttdef.h>
|
|
#include <iodef.h>
|
|
#include <starlet.h>
|
|
#include <unistd.h>
|
|
#include unixio
|
|
|
|
static int setbuff[2]; /* buffer to set terminal attributes */
|
|
static short chan = -1; /* channel to terminal */
|
|
struct dsc$descriptor_s descrip; /* VMS descriptor */
|
|
#endif
|
|
|
|
static void
|
|
sigar_getline_config(const char *which, int value)
|
|
{
|
|
if (strcmp(which, "noecho") == 0)
|
|
gl_no_echo = value;
|
|
else if (strcmp(which, "erase") == 0)
|
|
gl_erase_line = value;
|
|
else
|
|
printf("gl_config: %s ?\n", which);
|
|
}
|
|
|
|
static void
|
|
gl_char_init() /* turn off input echo */
|
|
{
|
|
if (gl_notty) return;
|
|
#ifdef unix
|
|
#ifdef TIOCGETP /* BSD */
|
|
ioctl(0, TIOCGETC, &tch);
|
|
ioctl(0, TIOCGLTC, <ch);
|
|
gl_intrc = tch.t_intrc;
|
|
gl_quitc = tch.t_quitc;
|
|
gl_suspc = ltch.t_suspc;
|
|
gl_dsuspc = ltch.t_dsuspc;
|
|
ioctl(0, TIOCGETP, &old_tty);
|
|
new_tty = old_tty;
|
|
new_tty.sg_flags |= RAW;
|
|
new_tty.sg_flags &= ~ECHO;
|
|
ioctl(0, TIOCSETP, &new_tty);
|
|
#else
|
|
#ifdef SIGTSTP /* POSIX */
|
|
tcgetattr(0, &old_termios);
|
|
gl_intrc = old_termios.c_cc[VINTR];
|
|
gl_quitc = old_termios.c_cc[VQUIT];
|
|
#ifdef VSUSP
|
|
gl_suspc = old_termios.c_cc[VSUSP];
|
|
#endif
|
|
#ifdef VDSUSP
|
|
gl_dsuspc = old_termios.c_cc[VDSUSP];
|
|
#endif
|
|
new_termios = old_termios;
|
|
new_termios.c_iflag &= ~(BRKINT|ISTRIP|IXON|IXOFF);
|
|
new_termios.c_iflag |= (IGNBRK|IGNPAR);
|
|
new_termios.c_lflag &= ~(ICANON|ISIG|IEXTEN|ECHO);
|
|
new_termios.c_cc[VMIN] = 1;
|
|
new_termios.c_cc[VTIME] = 0;
|
|
tcsetattr(0, TCSANOW, &new_termios);
|
|
#else /* SYSV */
|
|
ioctl(0, TCGETA, &old_termio);
|
|
gl_intrc = old_termio.c_cc[VINTR];
|
|
gl_quitc = old_termio.c_cc[VQUIT];
|
|
new_termio = old_termio;
|
|
new_termio.c_iflag &= ~(BRKINT|ISTRIP|IXON|IXOFF);
|
|
new_termio.c_iflag |= (IGNBRK|IGNPAR);
|
|
new_termio.c_lflag &= ~(ICANON|ISIG|ECHO);
|
|
new_termio.c_cc[VMIN] = 1;
|
|
new_termio.c_cc[VTIME] = 0;
|
|
ioctl(0, TCSETA, &new_termio);
|
|
#endif
|
|
#endif
|
|
#endif /* unix */
|
|
|
|
#ifdef MSDOS
|
|
gl_intrc = 'C' - '@';
|
|
gl_quitc = 'Q' - '@';
|
|
// gl_suspc = ltch.t_suspc;
|
|
#endif /* MSDOS */
|
|
|
|
#ifdef R__MWERKS
|
|
gl_intrc = 'C' - '@';
|
|
gl_quitc = 'Q' - '@';
|
|
#endif
|
|
|
|
#ifdef vms
|
|
descrip.dsc$w_length = strlen("tt:");
|
|
descrip.dsc$b_dtype = DSC$K_DTYPE_T;
|
|
descrip.dsc$b_class = DSC$K_CLASS_S;
|
|
descrip.dsc$a_pointer = "tt:";
|
|
(void)sys$assign(&descrip,&chan,0,0);
|
|
(void)sys$qiow(0,chan,IO$_SENSEMODE,0,0,0,setbuff,8,0,0,0,0);
|
|
setbuff[1] |= TT$M_NOECHO;
|
|
(void)sys$qiow(0,chan,IO$_SETMODE,0,0,0,setbuff,8,0,0,0,0);
|
|
#endif /* vms */
|
|
}
|
|
|
|
static void
|
|
gl_char_cleanup() /* undo effects of gl_char_init */
|
|
{
|
|
if (gl_notty) return;
|
|
#ifdef unix
|
|
#ifdef TIOCSETP /* BSD */
|
|
ioctl(0, TIOCSETP, &old_tty);
|
|
#else
|
|
#ifdef SIGTSTP /* POSIX */
|
|
tcsetattr(0, TCSANOW, &old_termios);
|
|
#else /* SYSV */
|
|
ioctl(0, TCSETA, &old_termio);
|
|
#endif
|
|
#endif
|
|
#endif /* unix */
|
|
|
|
#ifdef vms
|
|
setbuff[1] &= ~TT$M_NOECHO;
|
|
(void)sys$qiow(0,chan,IO$_SETMODE,0,0,0,setbuff,8,0,0,0,0);
|
|
sys$dassgn(chan);
|
|
chan = -1;
|
|
#endif
|
|
}
|
|
|
|
#if defined(MSDOS) && !defined(WIN32)
|
|
// +DECK, PAUSE, T=XCC, IF=WINNT. (from KERNDOS.CAR )
|
|
# include <conio.h>
|
|
int pause_()
|
|
{
|
|
int first_char;
|
|
first_char = _getch();
|
|
if (first_char == 0 || first_char == 0xE0) first_char = -_getch();
|
|
return first_char;
|
|
}
|
|
#endif
|
|
|
|
#if defined(MSDOS) && defined(WIN32)
|
|
//______________________________________________________________________________
|
|
int pause_()
|
|
{
|
|
static HANDLE hConsoleInput = NULL;
|
|
static iCharCount = 0;
|
|
static int chLastChar = 0;
|
|
|
|
DWORD cRead;
|
|
|
|
INPUT_RECORD pirBuffer;
|
|
KEY_EVENT_RECORD *KeyEvent= (KEY_EVENT_RECORD *)&(pirBuffer.Event);
|
|
|
|
if (!hConsoleInput) hConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
|
|
|
|
if (iCharCount) iCharCount--; // Whether several symbols had been read
|
|
else {
|
|
chLastChar = 0;
|
|
while (chLastChar == 0) {
|
|
if (!ReadConsoleInput(hConsoleInput, // handle of a console input buffer
|
|
&pirBuffer, // address of the buffer for read data
|
|
1, // number of records to read
|
|
&cRead // address of number of records read
|
|
)) return 0;
|
|
|
|
if (pirBuffer.EventType == KEY_EVENT && KeyEvent->bKeyDown == TRUE){
|
|
iCharCount = KeyEvent->wRepeatCount - 1;
|
|
chLastChar = ((int) (KeyEvent->uChar).AsciiChar & 0xffff);
|
|
if (chLastChar)
|
|
OemToCharBuff((char const *)&chLastChar,(char *)&chLastChar,1);
|
|
else
|
|
chLastChar = - (KeyEvent->wVirtualScanCode);
|
|
// chLastChar = - (KeyEvent->wVirtualKeyCode);
|
|
}
|
|
}
|
|
}
|
|
return chLastChar;
|
|
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
gl_getc()
|
|
/* get a character without echoing it to screen */
|
|
{
|
|
#ifdef MSDOS
|
|
# define k_ctrl_C 3
|
|
# define k_ctrl_Z 26
|
|
# define k_ctrl_Q 17
|
|
# define k_ctrl_K 11
|
|
# define k_rt_arr -77
|
|
# define k_lt_arr -75
|
|
# define k_up_arr -72
|
|
# define k_dn_arr -80
|
|
# define k_PGUP -73
|
|
# define k_PGDW -81
|
|
# define k_HOME -71
|
|
# define k_END -79
|
|
# define k_INS -82
|
|
# define k_DEL -83
|
|
# define k_ENTER 13
|
|
# define k_CR 13
|
|
# define k_BS 8
|
|
# define k_ESC 27
|
|
# define k_alt_H -35
|
|
# define k_beep 7
|
|
# ifndef WIN32
|
|
int get_cursor__(int *,int *);
|
|
int display_off__(int *);
|
|
int display_on__();
|
|
int locate_(int *,int *);
|
|
int ixc, iyc;
|
|
# endif
|
|
int pause_();
|
|
#endif
|
|
|
|
int c;
|
|
|
|
#if defined(unix)
|
|
unsigned char ch;
|
|
while ((c = (read(0, &ch, 1) > 0) ? ch : -1) == -1 && errno == EINTR)
|
|
errno = 0;
|
|
#endif
|
|
|
|
#if defined(R__MWERKS)
|
|
c = getchar();
|
|
#endif
|
|
|
|
#ifdef MSDOS
|
|
c = pause_();
|
|
if (c < 0) {
|
|
switch (c) {
|
|
case k_up_arr: c = 'P' - '@'; /* up -> ^P = 16 */
|
|
break;
|
|
case k_dn_arr: c = 'N' - '@'; /* down -> ^N = 14 */
|
|
break;
|
|
case k_lt_arr: c = 'B' - '@'; /* left -> ^B =2 */
|
|
break;
|
|
case k_rt_arr: c = 'F' - '@'; /* right -> ^F = 6*/
|
|
break;
|
|
case k_INS: c = 'O' - '@'; /* right -> ^O = 15*/
|
|
break;
|
|
case k_DEL: c = 'D' - '@'; /* Delete character under cursor = 4*/
|
|
break;
|
|
case k_END: c = 'E' - '@'; /* Moves cursor to end of line * = 5 */
|
|
break;
|
|
case k_HOME: c = 'A' - '@'; /* Moves cursor to beginning of line = 1*/
|
|
break;
|
|
default: c = 0; /* make it garbage */
|
|
}
|
|
}
|
|
else {
|
|
switch(c) {
|
|
case k_ESC: c = 'U' - '@'; /* Clear full line -> ^U */
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef vms
|
|
if(chan < 0) {
|
|
c='\0';
|
|
}
|
|
(void)sys$qiow(0,chan,IO$_TTYREADALL,0,0,0,&c,1,0,0,0,0);
|
|
c &= 0177; /* get a char */
|
|
#endif
|
|
return c;
|
|
}
|
|
|
|
static void
|
|
gl_putc(int c)
|
|
{
|
|
char ch = c;
|
|
|
|
if (gl_notty) return;
|
|
|
|
if ( !gl_passwd || !isgraph(c))
|
|
{
|
|
#ifdef WIN32
|
|
CharToOemBuff((char const *)&c,&ch,1);
|
|
#endif
|
|
|
|
write(1, &ch, 1);
|
|
}
|
|
#if defined(unix) || defined(MSDOS) || defined(WIN32) || defined(R__MWERKS)
|
|
#ifdef TIOCSETP /* BSD in RAW mode, map NL to NL,CR */
|
|
if (ch == '\n') {
|
|
ch = '\r';
|
|
write(1, &ch, 1);
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/******************** fairly portable part *********************************/
|
|
|
|
static void
|
|
gl_puts(char *buf)
|
|
{
|
|
int len = strlen(buf);
|
|
|
|
if (gl_notty) return;
|
|
#ifdef WIN32
|
|
{
|
|
char *OemBuf = (char *)malloc(2*len);
|
|
CharToOemBuff(buf,OemBuf,len);
|
|
write(1, OemBuf, len);
|
|
free(OemBuf);
|
|
}
|
|
#else
|
|
write(1, buf, len);
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
gl_error(char *buf)
|
|
{
|
|
int len = strlen(buf);
|
|
|
|
gl_cleanup();
|
|
#ifdef WIN32
|
|
{
|
|
char *OemBuf = (char *)malloc(2*len);
|
|
CharToOemBuff(buf,OemBuf,len);
|
|
write(2, OemBuf, len);
|
|
free(OemBuf);
|
|
}
|
|
#else
|
|
write(2, buf, len);
|
|
#endif
|
|
exit(1);
|
|
}
|
|
|
|
static void
|
|
gl_init()
|
|
/* set up variables and terminal */
|
|
{
|
|
if (gl_init_done < 0) { /* -1 only on startup */
|
|
hist_init();
|
|
}
|
|
if (isatty(0) == 0 || isatty(1) == 0)
|
|
gl_notty = 1;
|
|
gl_char_init();
|
|
gl_init_done = 1;
|
|
}
|
|
|
|
static void
|
|
gl_bell()
|
|
{
|
|
if (gl_bell_enabled) {
|
|
gl_putc('\007');
|
|
}
|
|
}
|
|
|
|
static void
|
|
gl_cleanup()
|
|
/* undo effects of gl_init, as necessary */
|
|
{
|
|
if (gl_init_done > 0)
|
|
gl_char_cleanup();
|
|
gl_init_done = 0;
|
|
}
|
|
|
|
SIGAR_DECLARE(void)
|
|
sigar_getline_setwidth(int w)
|
|
{
|
|
if (w > 20) {
|
|
gl_termw = w;
|
|
gl_scroll = w / 3;
|
|
} else {
|
|
gl_error("\n*** Error: minimum screen width is 21\n");
|
|
}
|
|
}
|
|
|
|
SIGAR_DECLARE(void)
|
|
sigar_getline_windowchanged()
|
|
{
|
|
#ifdef TIOCGWINSZ
|
|
if (isatty(0)) {
|
|
static char lenv[32], cenv[32];
|
|
struct winsize wins;
|
|
ioctl(0, TIOCGWINSZ, &wins);
|
|
|
|
if (wins.ws_col == 0) wins.ws_col = 80;
|
|
if (wins.ws_row == 0) wins.ws_row = 24;
|
|
|
|
sigar_getline_setwidth(wins.ws_col);
|
|
|
|
sprintf(lenv, "LINES=%d", wins.ws_row);
|
|
putenv(lenv);
|
|
sprintf(cenv, "COLUMNS=%d", wins.ws_col);
|
|
putenv(cenv);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* -1 = init, 0 = line mode, 1 = one char at a time mode, 2 = cleanup */
|
|
|
|
static char *
|
|
sigar_getlinem(int mode, char *prompt)
|
|
{
|
|
int c, loc, tmp;
|
|
int sig;
|
|
|
|
if (mode == 2) {
|
|
gl_cleanup();
|
|
return NULL;
|
|
}
|
|
|
|
if (mode < 1) {
|
|
if (mode == -1) {
|
|
sigar_getline_config("noecho", 0);
|
|
sigar_getline_config("erase", 0);
|
|
}
|
|
gl_init();
|
|
gl_prompt = (prompt)? prompt : (char*)"";
|
|
gl_buf[0] = 0;
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, -2, BUF_SIZE);
|
|
if (mode == -1) return NULL;
|
|
}
|
|
while ((c = gl_getc()) >= 0) {
|
|
gl_extent = 0; /* reset to full extent */
|
|
#ifndef WIN32
|
|
if (isprint(c)) {
|
|
#else
|
|
if (c >= ' ') {
|
|
#endif
|
|
if (gl_search_mode)
|
|
search_addchar(c);
|
|
else
|
|
gl_addchar(c);
|
|
} else {
|
|
if (gl_search_mode) {
|
|
if (c == '\033' || c == '\016' || c == '\020') {
|
|
search_term();
|
|
c = 0; /* ignore the character */
|
|
} else if (c == '\010' || c == '\177') {
|
|
search_addchar(-1); /* unwind search string */
|
|
c = 0;
|
|
} else if (c != '\022' && c != '\023') {
|
|
search_term(); /* terminate and handle char */
|
|
}
|
|
}
|
|
/* NOTE:
|
|
* sometimes M-x turns on bit 8 ( M-x --> 'x' + 128 )
|
|
* sometimes M-x prepends an escape character ( M-x --> '\033','x' )
|
|
* both cases are handled ...
|
|
*/
|
|
switch (c)
|
|
{
|
|
case 'b'+128: /* M-b */
|
|
case 'B'+128: /* M-B */
|
|
gl_back_1_word();
|
|
break;
|
|
case 'd'+128: /* M-d */
|
|
case 'D'+128: /* M-D */
|
|
gl_kill_1_word();
|
|
break;
|
|
case 'f'+128: /* M-f */
|
|
case 'F'+128: /* M-F */
|
|
gl_fwd_1_word();
|
|
break;
|
|
case '\000': /* ^SPC */
|
|
gl_set_mark();
|
|
break;
|
|
case '\027': /* ^W */
|
|
gl_wipe();
|
|
break;
|
|
case '\030': /* ^X */
|
|
gl_exch();
|
|
break;
|
|
case '\n': /* newline */
|
|
case '\r':
|
|
gl_newline();
|
|
gl_cleanup();
|
|
return gl_buf;
|
|
/*NOTREACHED*/
|
|
break;
|
|
case '\001': gl_fixup(gl_prompt, -1, 0); /* ^A */
|
|
break;
|
|
case '\002': gl_fixup(gl_prompt, -1, gl_pos-1); /* ^B */
|
|
break;
|
|
case '\004': /* ^D */
|
|
if (gl_cnt == 0) {
|
|
gl_buf[0] = 0;
|
|
gl_cleanup();
|
|
gl_putc('\n');
|
|
return gl_buf;
|
|
} else {
|
|
gl_del(0);
|
|
}
|
|
break;
|
|
case '\005': gl_fixup(gl_prompt, -1, gl_cnt); /* ^E */
|
|
break;
|
|
case '\006': gl_fixup(gl_prompt, -1, gl_pos+1); /* ^F */
|
|
break;
|
|
case '\010': case '\177': gl_del(-1); /* ^H and DEL */
|
|
break;
|
|
case '\t': /* TAB */
|
|
if (gl_tab_hook) {
|
|
tmp = gl_pos;
|
|
loc = gl_tab_hook(gl_buf, strlen(gl_prompt), &tmp);
|
|
if (loc >= 0 || tmp != gl_pos || loc == -2)
|
|
gl_fixup(gl_prompt, loc, tmp);
|
|
}
|
|
break;
|
|
case '\013': gl_kill(); /* ^K */
|
|
break;
|
|
case '\014': sigar_getline_clear_screen(); /* ^L */
|
|
break;
|
|
case '\016': /* ^N */
|
|
strcpy(gl_buf, hist_next());
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, 0, BUF_SIZE);
|
|
break;
|
|
case '\017': gl_overwrite = !gl_overwrite; /* ^O */
|
|
break;
|
|
case '\020': /* ^P */
|
|
strcpy(gl_buf, hist_prev());
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, 0, BUF_SIZE);
|
|
break;
|
|
case '\022': search_back(1); /* ^R */
|
|
break;
|
|
case '\023': search_forw(1); /* ^S */
|
|
break;
|
|
case '\024': gl_transpose(); /* ^T */
|
|
break;
|
|
case '\025': gl_fixup(gl_prompt,-1,0); gl_kill(); /* ^U */
|
|
break;
|
|
case '\031': gl_yank(); /* ^Y */
|
|
break;
|
|
case '\033':
|
|
switch(c = gl_getc())
|
|
{
|
|
case 'b': /* M-b */
|
|
case 'B': /* M-B */
|
|
gl_back_1_word();
|
|
break;
|
|
case 'd': /* M-d */
|
|
case 'D': /* M-D */
|
|
gl_kill_1_word();
|
|
break;
|
|
case 'f': /* M-f */
|
|
case 'F': /* M-F */
|
|
gl_fwd_1_word();
|
|
break;
|
|
case '[': /* ansi arrow keys */
|
|
case 'O': /* xterm arrow keys */
|
|
switch(c = gl_getc())
|
|
{
|
|
case 'A': /* up */
|
|
strcpy(gl_buf, hist_prev());
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, 0, BUF_SIZE);
|
|
break;
|
|
case 'B': /* down */
|
|
strcpy(gl_buf, hist_next());
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, 0, BUF_SIZE);
|
|
break;
|
|
case 'C': gl_fixup(gl_prompt, -1, gl_pos+1); /* right */
|
|
break;
|
|
case 'D': gl_fixup(gl_prompt, -1, gl_pos-1); /* left */
|
|
break;
|
|
default: /* who knows */
|
|
gl_bell();
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
gl_bell();
|
|
}
|
|
break;
|
|
default: /* check for a terminal signal */
|
|
|
|
#if defined(unix) || defined(WIN32) || defined(R__MWERKS)
|
|
if (c > 0) { /* ignore 0 (reset above) */
|
|
sig = 0;
|
|
#ifdef SIGINT
|
|
if (c == gl_intrc)
|
|
sig = SIGINT;
|
|
#endif
|
|
#ifdef SIGQUIT
|
|
if (c == gl_quitc)
|
|
sig = SIGQUIT;
|
|
#endif
|
|
#ifdef SIGTSTP
|
|
if (c == gl_suspc || c == gl_dsuspc)
|
|
sig = SIGTSTP;
|
|
#endif
|
|
if (sig != 0) {
|
|
gl_cleanup();
|
|
#if !defined(WIN32)
|
|
raise(sig);
|
|
#endif
|
|
#ifdef WIN32
|
|
if (sig == SIGINT) GenerateConsoleCtrlEvent(CTRL_C_EVENT,0);
|
|
else raise(sig);
|
|
#endif
|
|
gl_init();
|
|
sigar_getline_redraw();
|
|
c = 0;
|
|
}
|
|
}
|
|
#endif /* unix */
|
|
if (c > 0)
|
|
gl_bell();
|
|
break;
|
|
}
|
|
}
|
|
if (mode == 1) return NULL;
|
|
}
|
|
if (c == -1 && gl_notty)
|
|
gl_eof = 1;
|
|
else
|
|
gl_eof = 0;
|
|
|
|
gl_cleanup();
|
|
gl_buf[0] = 0;
|
|
return gl_buf;
|
|
}
|
|
|
|
SIGAR_DECLARE(int)
|
|
sigar_getline_eof()
|
|
{
|
|
return gl_eof;
|
|
}
|
|
|
|
SIGAR_DECLARE(char *)
|
|
sigar_getline(char *prompt)
|
|
{
|
|
return sigar_getlinem(0, prompt);
|
|
}
|
|
|
|
static void
|
|
gl_addchar(int c)
|
|
/* adds the character c to the input buffer at current location */
|
|
{
|
|
int i;
|
|
|
|
if (gl_cnt >= BUF_SIZE - 1)
|
|
gl_error("\n*** Error: sigar_getline(): input buffer overflow\n");
|
|
if (gl_overwrite == 0 || gl_pos == gl_cnt) {
|
|
for (i=gl_cnt; i >= gl_pos; i--)
|
|
gl_buf[i+1] = gl_buf[i];
|
|
gl_buf[gl_pos] = c;
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos+1);
|
|
} else {
|
|
gl_buf[gl_pos] = c;
|
|
gl_extent = 1;
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos+1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gl_yank()
|
|
/* adds the kill buffer to the input buffer at current location */
|
|
{
|
|
int i, len;
|
|
|
|
len = strlen(gl_killbuf);
|
|
if (len > 0) {
|
|
gl_mark = gl_pos;
|
|
if (gl_overwrite == 0) {
|
|
if (gl_cnt + len >= BUF_SIZE - 1)
|
|
gl_error("\n*** Error: sigar_getline(): input buffer overflow\n");
|
|
for (i=gl_cnt; i >= gl_pos; i--)
|
|
gl_buf[i+len] = gl_buf[i];
|
|
for (i=0; i < len; i++)
|
|
gl_buf[gl_pos+i] = gl_killbuf[i];
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos+len);
|
|
} else {
|
|
if (gl_pos + len > gl_cnt) {
|
|
if (gl_pos + len >= BUF_SIZE - 1)
|
|
gl_error("\n*** Error: sigar_getline(): input buffer overflow\n");
|
|
gl_buf[gl_pos + len] = 0;
|
|
}
|
|
for (i=0; i < len; i++)
|
|
gl_buf[gl_pos+i] = gl_killbuf[i];
|
|
gl_extent = len;
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos+len);
|
|
}
|
|
} else
|
|
gl_bell();
|
|
}
|
|
|
|
static void
|
|
gl_transpose()
|
|
/* switch character under cursor and to left of cursor */
|
|
{
|
|
int c;
|
|
|
|
if (gl_pos > 0 && gl_cnt > gl_pos) {
|
|
c = gl_buf[gl_pos-1];
|
|
gl_buf[gl_pos-1] = gl_buf[gl_pos];
|
|
gl_buf[gl_pos] = c;
|
|
gl_extent = 2;
|
|
gl_fixup(gl_prompt, gl_pos-1, gl_pos);
|
|
} else
|
|
gl_bell();
|
|
}
|
|
|
|
static void
|
|
gl_newline()
|
|
/*
|
|
* Cleans up entire line before returning to caller. A \n is appended.
|
|
* If line longer than screen, we redraw starting at beginning
|
|
*/
|
|
{
|
|
int change = gl_cnt;
|
|
int len = gl_cnt;
|
|
int loc = gl_width - 5; /* shifts line back to start position */
|
|
|
|
if (gl_cnt >= BUF_SIZE - 1)
|
|
gl_error("\n*** Error: sigar_getline(): input buffer overflow\n");
|
|
if (gl_out_hook) {
|
|
change = gl_out_hook(gl_buf);
|
|
len = strlen(gl_buf);
|
|
}
|
|
if (gl_erase_line) {
|
|
char gl_buf0 = gl_buf[0];
|
|
gl_buf[0] = '\0';
|
|
gl_fixup("", 0, 0);
|
|
gl_buf[0] = gl_buf0;
|
|
}
|
|
else {
|
|
if (loc > len)
|
|
loc = len;
|
|
gl_fixup(gl_prompt, change, loc); /* must do this before appending \n */
|
|
gl_putc('\n');
|
|
}
|
|
#if 0
|
|
gl_buf[len] = '\n';
|
|
gl_buf[len+1] = '\0';
|
|
#endif
|
|
gl_mark = -1;
|
|
}
|
|
|
|
static void
|
|
gl_del(int loc)
|
|
/*
|
|
* Delete a character. The loc variable can be:
|
|
* -1 : delete character to left of cursor
|
|
* 0 : delete character under cursor
|
|
*/
|
|
{
|
|
int i;
|
|
|
|
if ((loc == -1 && gl_pos > 0) || (loc == 0 && gl_pos < gl_cnt)) {
|
|
for (i=gl_pos+loc; i < gl_cnt; i++)
|
|
gl_buf[i] = gl_buf[i+1];
|
|
gl_fixup(gl_prompt, gl_pos+loc, gl_pos+loc);
|
|
} else
|
|
gl_bell();
|
|
}
|
|
|
|
static void
|
|
gl_kill()
|
|
/* delete from current position to the end of line */
|
|
{
|
|
if (gl_pos < gl_cnt) {
|
|
strcpy(gl_killbuf, gl_buf + gl_pos);
|
|
gl_buf[gl_pos] = '\0';
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos);
|
|
} else
|
|
gl_bell();
|
|
}
|
|
|
|
SIGAR_DECLARE(void) sigar_getline_redraw(void)
|
|
/* emit a newline, reset and redraw prompt and current input line */
|
|
{
|
|
if (gl_init_done > 0) {
|
|
gl_putc('\n');
|
|
gl_fixup(gl_prompt, -2, gl_pos);
|
|
}
|
|
}
|
|
|
|
#define CLEAR_SCREEN "\033[2J"
|
|
|
|
static void sigar_getline_clear_screen(void)
|
|
{
|
|
if (gl_init_done > 0) {
|
|
gl_putc('\n');
|
|
/* XXX what to do for non-ansi term? */
|
|
gl_puts(CLEAR_SCREEN);
|
|
gl_fixup(gl_prompt, -2, gl_pos);
|
|
}
|
|
}
|
|
|
|
SIGAR_DECLARE(void) sigar_getline_reset(void)
|
|
{
|
|
gl_fixup(gl_prompt,-1,0);
|
|
gl_kill();
|
|
}
|
|
|
|
static void
|
|
gl_fixup(char *prompt, int change, int cursor)
|
|
/*
|
|
* This function is used both for redrawing when input changes or for
|
|
* moving within the input line. The parameters are:
|
|
* prompt: compared to last_prompt[] for changes;
|
|
* change : the index of the start of changes in the input buffer,
|
|
* with -1 indicating no changes, -2 indicating we're on
|
|
* a new line, redraw everything.
|
|
* cursor : the desired location of the cursor after the call.
|
|
* A value of BUF_SIZE can be used to indicate the cursor should
|
|
* move just past the end of the input line.
|
|
*/
|
|
{
|
|
static int gl_shift; /* index of first on screen character */
|
|
static int off_right; /* true if more text right of screen */
|
|
static int off_left; /* true if more text left of screen */
|
|
static char last_prompt[BUF_SIZE] = "";
|
|
int left = 0, right = -1; /* bounds for redraw */
|
|
int padl; /* how much to erase at end of line */
|
|
int backup; /* how far to backup before fixing */
|
|
int new_shift; /* value of shift based on cursor */
|
|
int extra; /* adjusts when shift (scroll) happens */
|
|
int i;
|
|
int new_right = -1; /* alternate right bound, using gl_extent */
|
|
int l1, l2;
|
|
|
|
if (change == -2) { /* reset */
|
|
gl_pos = gl_cnt = gl_shift = off_right = off_left = 0;
|
|
gl_passwd = 0;
|
|
gl_puts(prompt);
|
|
gl_passwd = gl_no_echo;
|
|
strcpy(last_prompt, prompt);
|
|
change = 0;
|
|
gl_width = gl_termw - strlen(prompt);
|
|
} else if (strcmp(prompt, last_prompt) != 0) {
|
|
l1 = strlen(last_prompt);
|
|
l2 = strlen(prompt);
|
|
gl_cnt = gl_cnt + l1 - l2;
|
|
strcpy(last_prompt, prompt);
|
|
backup = gl_pos - gl_shift + l1;
|
|
for (i=0; i < backup; i++)
|
|
gl_putc('\b');
|
|
gl_passwd = 0;
|
|
gl_puts(prompt);
|
|
gl_passwd = gl_no_echo;
|
|
gl_pos = gl_shift;
|
|
gl_width = gl_termw - l2;
|
|
change = 0;
|
|
}
|
|
padl = (off_right)? gl_width - 1 : gl_cnt - gl_shift; /* old length */
|
|
backup = gl_pos - gl_shift;
|
|
if (change >= 0) {
|
|
gl_cnt = strlen(gl_buf);
|
|
if (change > gl_cnt)
|
|
change = gl_cnt;
|
|
}
|
|
if (cursor > gl_cnt) {
|
|
if (cursor != BUF_SIZE) /* BUF_SIZE means end of line */
|
|
gl_bell();
|
|
cursor = gl_cnt;
|
|
}
|
|
if (cursor < 0) {
|
|
gl_bell();
|
|
cursor = 0;
|
|
}
|
|
if (off_right || (off_left && cursor < gl_shift + gl_width - gl_scroll / 2))
|
|
extra = 2; /* shift the scrolling boundary */
|
|
else
|
|
extra = 0;
|
|
new_shift = cursor + extra + gl_scroll - gl_width;
|
|
if (new_shift > 0) {
|
|
new_shift /= gl_scroll;
|
|
new_shift *= gl_scroll;
|
|
} else
|
|
new_shift = 0;
|
|
if (new_shift != gl_shift) { /* scroll occurs */
|
|
gl_shift = new_shift;
|
|
off_left = (gl_shift)? 1 : 0;
|
|
off_right = (gl_cnt > gl_shift + gl_width - 1)? 1 : 0;
|
|
left = gl_shift;
|
|
new_right = right = (off_right)? gl_shift + gl_width - 2 : gl_cnt;
|
|
} else if (change >= 0) { /* no scroll, but text changed */
|
|
if (change < gl_shift + off_left) {
|
|
left = gl_shift;
|
|
} else {
|
|
left = change;
|
|
backup = gl_pos - change;
|
|
}
|
|
off_right = (gl_cnt > gl_shift + gl_width - 1)? 1 : 0;
|
|
right = (off_right)? gl_shift + gl_width - 2 : gl_cnt;
|
|
new_right = (gl_extent && (right > left + gl_extent))?
|
|
left + gl_extent : right;
|
|
}
|
|
padl -= (off_right)? gl_width - 1 : gl_cnt - gl_shift;
|
|
padl = (padl < 0)? 0 : padl;
|
|
if (left <= right) { /* clean up screen */
|
|
for (i=0; i < backup; i++)
|
|
gl_putc('\b');
|
|
if (left == gl_shift && off_left) {
|
|
gl_putc('$');
|
|
left++;
|
|
}
|
|
for (i=left; i < new_right; i++)
|
|
gl_putc(gl_buf[i]);
|
|
gl_pos = new_right;
|
|
if (off_right && new_right == right) {
|
|
gl_putc('$');
|
|
gl_pos++;
|
|
} else {
|
|
for (i=0; i < padl; i++) /* erase remains of prev line */
|
|
gl_putc(' ');
|
|
gl_pos += padl;
|
|
}
|
|
}
|
|
i = gl_pos - cursor; /* move to final cursor location */
|
|
if (i > 0) {
|
|
while (i--)
|
|
gl_putc('\b');
|
|
} else {
|
|
for (i=gl_pos; i < cursor; i++)
|
|
gl_putc(gl_buf[i]);
|
|
}
|
|
gl_pos = cursor;
|
|
}
|
|
|
|
static int
|
|
gl_tab(char *buf, int offset, int *loc)
|
|
/* default tab handler, acts like tabstops every 8 cols */
|
|
{
|
|
int i, count, len;
|
|
|
|
len = strlen(buf);
|
|
count = 8 - (offset + *loc) % 8;
|
|
for (i=len; i >= *loc; i--)
|
|
buf[i+count] = buf[i];
|
|
for (i=0; i < count; i++)
|
|
buf[*loc+i] = ' ';
|
|
i = *loc;
|
|
*loc = i + count;
|
|
return i;
|
|
}
|
|
|
|
/******************* History stuff **************************************/
|
|
|
|
#ifndef HIST_SIZE
|
|
#define HIST_SIZE 100
|
|
#endif
|
|
|
|
static int hist_pos = 0, hist_last = 0;
|
|
static char *hist_buf[HIST_SIZE];
|
|
|
|
static void
|
|
hist_init()
|
|
{
|
|
int i;
|
|
|
|
if (gl_savehist) return;
|
|
|
|
hist_buf[0] = "";
|
|
for (i=1; i < HIST_SIZE; i++)
|
|
hist_buf[i] = (char *)0;
|
|
}
|
|
|
|
SIGAR_DECLARE(void) sigar_getline_completer_set(sigar_getline_completer_t func)
|
|
{
|
|
if (func) {
|
|
gl_tab_hook = func;
|
|
}
|
|
else {
|
|
gl_tab_hook = gl_tab;
|
|
}
|
|
}
|
|
|
|
SIGAR_DECLARE(void)
|
|
sigar_getline_histinit(char *file)
|
|
{
|
|
char line[256];
|
|
FILE *fp;
|
|
int nline = 1; /* prevent from becoming 0 */
|
|
|
|
gl_savehist = 0;
|
|
|
|
hist_init();
|
|
|
|
if (!strcmp(file, "-")) return;
|
|
|
|
sprintf(gl_histfile, "%s", file);
|
|
|
|
fp = fopen(gl_histfile, "r");
|
|
if (fp)
|
|
while (fgets(line, 256, fp)) {
|
|
nline++;
|
|
sigar_getline_histadd(line);
|
|
}
|
|
else
|
|
fp = fopen(gl_histfile, "w");
|
|
|
|
if (fp) fclose(fp);
|
|
|
|
gl_savehist = nline;
|
|
}
|
|
|
|
SIGAR_DECLARE(void)
|
|
sigar_getline_histadd(char *buf)
|
|
{
|
|
static char *prev = 0;
|
|
char *p = buf;
|
|
int len;
|
|
|
|
while (*p == ' ' || *p == '\t' || *p == '\n')
|
|
p++;
|
|
if (*p) {
|
|
len = strlen(buf);
|
|
if (strchr(p, '\n')) /* previously line already has NL stripped */
|
|
len--;
|
|
if (prev == 0 || strlen(prev) != len ||
|
|
strncmp(prev, buf, len) != 0) {
|
|
hist_buf[hist_last] = hist_save(buf);
|
|
prev = hist_buf[hist_last];
|
|
hist_last = (hist_last + 1) % HIST_SIZE;
|
|
if (hist_buf[hist_last] && *hist_buf[hist_last]) {
|
|
free(hist_buf[hist_last]);
|
|
}
|
|
hist_buf[hist_last] = "";
|
|
|
|
/* append command to history file */
|
|
if (gl_savehist) {
|
|
FILE *fp;
|
|
fp = fopen(gl_histfile, "a+");
|
|
if (fp) {
|
|
fprintf(fp, "%s\n", prev);
|
|
gl_savehist++;
|
|
fclose(fp);
|
|
}
|
|
|
|
/* if more than HIST_SIZE lines, safe last 60 command and delete rest */
|
|
if (gl_savehist > HIST_SIZE) {
|
|
FILE *ftmp;
|
|
char tname[L_tmpnam];
|
|
char line[BUFSIZ];
|
|
|
|
fp = fopen(gl_histfile, "r");
|
|
tmpnam(tname);
|
|
ftmp = fopen(tname, "w");
|
|
if (fp && ftmp) {
|
|
int nline = 0;
|
|
while (fgets(line, BUFSIZ, fp)) {
|
|
nline++;
|
|
gl_savehist = 1; /* prevent from becoming 0 */
|
|
if (nline > HIST_SIZE-60) {
|
|
gl_savehist++;
|
|
fprintf(ftmp, "%s", line);
|
|
}
|
|
}
|
|
}
|
|
if (fp) fclose(fp);
|
|
if (ftmp) fclose(ftmp);
|
|
|
|
/* copy back to history file */
|
|
fp = fopen(gl_histfile, "w");
|
|
ftmp = fopen(tname, "r");
|
|
if (fp && ftmp)
|
|
while (fgets(line, BUFSIZ, ftmp))
|
|
fprintf(fp, "%s", line);
|
|
|
|
if (fp) fclose(fp);
|
|
if (ftmp) fclose(ftmp);
|
|
remove(tname);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
hist_pos = hist_last;
|
|
}
|
|
|
|
static char *
|
|
hist_prev()
|
|
/* loads previous hist entry into input buffer, sticks on first */
|
|
{
|
|
char *p = 0;
|
|
int next = (hist_pos - 1 + HIST_SIZE) % HIST_SIZE;
|
|
|
|
if (hist_buf[hist_pos] != 0 && next != hist_last) {
|
|
hist_pos = next;
|
|
p = hist_buf[hist_pos];
|
|
}
|
|
if (p == 0) {
|
|
p = "";
|
|
gl_bell();
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static char *
|
|
hist_next()
|
|
/* loads next hist entry into input buffer, clears on last */
|
|
{
|
|
char *p = 0;
|
|
|
|
if (hist_pos != hist_last) {
|
|
hist_pos = (hist_pos+1) % HIST_SIZE;
|
|
p = hist_buf[hist_pos];
|
|
}
|
|
if (p == 0) {
|
|
p = "";
|
|
gl_bell();
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static char *
|
|
hist_save(char *p)
|
|
/* makes a copy of the string */
|
|
{
|
|
char *s = 0;
|
|
int len = strlen(p);
|
|
char *nl = strchr(p, '\n');
|
|
|
|
if (nl) {
|
|
if ((s = (char *)malloc(len)) != 0) {
|
|
strncpy(s, p, len-1);
|
|
s[len-1] = 0;
|
|
}
|
|
} else {
|
|
if ((s = (char *)malloc(len+1)) != 0) {
|
|
strcpy(s, p);
|
|
}
|
|
}
|
|
if (s == 0)
|
|
gl_error("\n*** Error: hist_save() failed on malloc\n");
|
|
return s;
|
|
}
|
|
|
|
/******************* Search stuff **************************************/
|
|
|
|
static char search_prompt[101]; /* prompt includes search string */
|
|
static char search_string[100];
|
|
static int search_pos = 0; /* current location in search_string */
|
|
static int search_forw_flg = 0; /* search direction flag */
|
|
static int search_last = 0; /* last match found */
|
|
|
|
static void
|
|
search_update(int c)
|
|
{
|
|
if (c == 0) {
|
|
search_pos = 0;
|
|
search_string[0] = 0;
|
|
search_prompt[0] = '?';
|
|
search_prompt[1] = ' ';
|
|
search_prompt[2] = 0;
|
|
} else if (c > 0) {
|
|
search_string[search_pos] = c;
|
|
search_string[search_pos+1] = 0;
|
|
search_prompt[search_pos] = c;
|
|
search_prompt[search_pos+1] = '?';
|
|
search_prompt[search_pos+2] = ' ';
|
|
search_prompt[search_pos+3] = 0;
|
|
search_pos++;
|
|
} else {
|
|
if (search_pos > 0) {
|
|
search_pos--;
|
|
search_string[search_pos] = 0;
|
|
search_prompt[search_pos] = '?';
|
|
search_prompt[search_pos+1] = ' ';
|
|
search_prompt[search_pos+2] = 0;
|
|
} else {
|
|
gl_bell();
|
|
hist_pos = hist_last;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
search_addchar(int c)
|
|
{
|
|
char *loc;
|
|
|
|
search_update(c);
|
|
if (c < 0) {
|
|
if (search_pos > 0) {
|
|
hist_pos = search_last;
|
|
} else {
|
|
gl_buf[0] = 0;
|
|
hist_pos = hist_last;
|
|
}
|
|
strcpy(gl_buf, hist_buf[hist_pos]);
|
|
}
|
|
if ((loc = strstr(gl_buf, search_string)) != 0) {
|
|
gl_fixup(search_prompt, 0, loc - gl_buf);
|
|
} else if (search_pos > 0) {
|
|
if (search_forw_flg) {
|
|
search_forw(0);
|
|
} else {
|
|
search_back(0);
|
|
}
|
|
} else {
|
|
gl_fixup(search_prompt, 0, 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
search_term()
|
|
{
|
|
gl_search_mode = 0;
|
|
if (gl_buf[0] == 0) /* not found, reset hist list */
|
|
hist_pos = hist_last;
|
|
if (gl_in_hook)
|
|
gl_in_hook(gl_buf);
|
|
gl_fixup(gl_prompt, 0, gl_pos);
|
|
}
|
|
|
|
static void
|
|
search_back(int new_search)
|
|
{
|
|
int found = 0;
|
|
char *p, *loc;
|
|
|
|
search_forw_flg = 0;
|
|
if (gl_search_mode == 0) {
|
|
search_last = hist_pos = hist_last;
|
|
search_update(0);
|
|
gl_search_mode = 1;
|
|
gl_buf[0] = 0;
|
|
gl_fixup(search_prompt, 0, 0);
|
|
} else if (search_pos > 0) {
|
|
while (!found) {
|
|
p = hist_prev();
|
|
if (*p == 0) { /* not found, done looking */
|
|
gl_buf[0] = 0;
|
|
gl_fixup(search_prompt, 0, 0);
|
|
found = 1;
|
|
} else if ((loc = strstr(p, search_string)) != 0) {
|
|
strcpy(gl_buf, p);
|
|
gl_fixup(search_prompt, 0, loc - p);
|
|
if (new_search)
|
|
search_last = hist_pos;
|
|
found = 1;
|
|
}
|
|
}
|
|
} else {
|
|
gl_bell();
|
|
}
|
|
}
|
|
|
|
static void
|
|
search_forw(int new_search)
|
|
{
|
|
int found = 0;
|
|
char *p, *loc;
|
|
|
|
search_forw_flg = 1;
|
|
if (gl_search_mode == 0) {
|
|
search_last = hist_pos = hist_last;
|
|
search_update(0);
|
|
gl_search_mode = 1;
|
|
gl_buf[0] = 0;
|
|
gl_fixup(search_prompt, 0, 0);
|
|
} else if (search_pos > 0) {
|
|
while (!found) {
|
|
p = hist_next();
|
|
if (*p == 0) { /* not found, done looking */
|
|
gl_buf[0] = 0;
|
|
gl_fixup(search_prompt, 0, 0);
|
|
found = 1;
|
|
} else if ((loc = strstr(p, search_string)) != 0) {
|
|
strcpy(gl_buf, p);
|
|
gl_fixup(search_prompt, 0, loc - p);
|
|
if (new_search)
|
|
search_last = hist_pos;
|
|
found = 1;
|
|
}
|
|
}
|
|
} else {
|
|
gl_bell();
|
|
}
|
|
}
|
|
#if 0
|
|
/***********************************************************************
|
|
* *
|
|
* Strip blanks from both sides of a string. Space for the new *
|
|
* string is allocated and a pointer to it is returned. *
|
|
* *
|
|
***********************************************************************/
|
|
char *strip(char *s)
|
|
{
|
|
char *r, *t1, *t2;
|
|
int l;
|
|
|
|
l = strlen(s);
|
|
r = (char *)calloc(l+1, 1);
|
|
|
|
if (l == 0) {
|
|
*r = '\0';
|
|
return r;
|
|
}
|
|
|
|
/* get rid of leading blanks */
|
|
t1 = s;
|
|
while (*t1 == ' ')
|
|
t1++;
|
|
|
|
t2 = s + l - 1;
|
|
while (*t2 == ' ' && t2 > s)
|
|
t2--;
|
|
|
|
if (t1 > t2) {
|
|
*r = '\0';
|
|
return r;
|
|
}
|
|
strncpy(r, t1, (size_t) (t2-t1+1));
|
|
|
|
return r;
|
|
}
|
|
#endif
|
|
/*****************************************************************************/
|
|
/* Extra routine provided by Christian Lacunza <lacunza@cdfsg5.lbl.gov> */
|
|
/*****************************************************************************/
|
|
|
|
/* move cursor back to beginning of _current_ word */
|
|
/* unless it's already at the beginning, */
|
|
/* in which case it moves back to the beginning */
|
|
/* of the _previous_ word. */
|
|
static void gl_back_1_word( void )
|
|
{
|
|
int i = gl_pos;
|
|
|
|
/* if we're at the beginning of a word, */
|
|
/* slip back into the preceeding whitespace */
|
|
if( i>0 && is_whitespace(gl_buf[i-1]) ) {
|
|
i-=1;
|
|
}
|
|
|
|
/* now move back over all consecutive whitespace */
|
|
while( i>0 && is_whitespace(gl_buf[i]) ) {
|
|
i-=1;
|
|
}
|
|
|
|
/* now keep moving back over all consecutive non-whitespace */
|
|
/* until we find the beginning of this word. */
|
|
/* ie. stop just before more whitespace shows up. */
|
|
while( i>0 && !is_whitespace(gl_buf[i-1]) ) {
|
|
i-=1;
|
|
}
|
|
|
|
/* move the cursor here */
|
|
gl_fixup(gl_prompt, -1, i);
|
|
}
|
|
|
|
/* kills from current position to end of word */
|
|
static void gl_kill_1_word( void )
|
|
{
|
|
int i = gl_pos;
|
|
int j = gl_pos;
|
|
|
|
/* delete this: */
|
|
#if 0
|
|
/* not sure what to do with "punctuation" */
|
|
if( is_whitespace(gl_buf[j]) && gl_buf[j]!=' ' ) {
|
|
return;
|
|
}
|
|
/* first find a word */
|
|
while( j<gl_cnt && gl_buf[j]==' ' ) {
|
|
j+=1;
|
|
}
|
|
#endif
|
|
|
|
/* first find a word */
|
|
while( j<gl_cnt && is_whitespace(gl_buf[j]) ) {
|
|
j+=1;
|
|
}
|
|
|
|
/* next, find the end of this word. */
|
|
while( j<gl_cnt && !is_whitespace(gl_buf[j+1]) ) {
|
|
j+=1;
|
|
}
|
|
|
|
/* kill */
|
|
gl_kill_region( i, j );
|
|
|
|
/* fixup */
|
|
gl_fixup(gl_prompt, gl_pos, gl_pos);
|
|
}
|
|
|
|
static void gl_kill_region( int i, int j )
|
|
{
|
|
/* copy to kill buffer */
|
|
strncpy( gl_killbuf, gl_buf+i, j-i+1 );
|
|
gl_killbuf[j-i+1]='\0';
|
|
|
|
/* remove from gl_buf */
|
|
while( j<gl_cnt ) {
|
|
gl_buf[i]=gl_buf[j+1];
|
|
i+=1;
|
|
j+=1;
|
|
}
|
|
gl_buf[i]='\0';
|
|
}
|
|
|
|
/* move cursor forward to the beginning of the next word. */
|
|
static void gl_fwd_1_word( void )
|
|
{
|
|
int i = gl_pos;
|
|
|
|
/* move past all non-whitespace into the whitespace between words. */
|
|
while( i<gl_cnt && !is_whitespace(gl_buf[i]) ) {
|
|
i+=1;
|
|
}
|
|
|
|
/* move past this whitespace to the beginning of the next word. */
|
|
while( i<gl_cnt && is_whitespace(gl_buf[i]) ) {
|
|
i+=1;
|
|
}
|
|
|
|
/* move the cursor here. */
|
|
gl_fixup(gl_prompt, -1, i);
|
|
}
|
|
|
|
/* NOTE: "whitespace" is very loosely defined. */
|
|
static int is_whitespace( char c )
|
|
{
|
|
int decent_character;
|
|
|
|
decent_character = sigar_isalpha(c) || sigar_isdigit(c) || c=='_';
|
|
|
|
return !decent_character;
|
|
}
|
|
|
|
/* sets mark to be at point */
|
|
static void gl_set_mark( void )
|
|
{
|
|
gl_mark = gl_pos;
|
|
}
|
|
|
|
/* kills from mark to point */
|
|
static void gl_wipe( void )
|
|
{
|
|
int left, right;
|
|
|
|
if( gl_mark < 0 ) return;
|
|
if( gl_mark == gl_pos ) return;
|
|
|
|
if( gl_mark < gl_pos ) {
|
|
left = gl_mark;
|
|
right = gl_pos;
|
|
}
|
|
else {
|
|
left = gl_pos;
|
|
right = gl_mark;
|
|
}
|
|
|
|
gl_kill_region( left, right-1 );
|
|
gl_fixup( gl_prompt, left, left );
|
|
}
|
|
|
|
/* echanges point and mark */
|
|
static void gl_exch( void )
|
|
{
|
|
int tmp;
|
|
|
|
/* make sure mark is set */
|
|
if( gl_mark < 0 ) return;
|
|
|
|
tmp = gl_pos;
|
|
gl_fixup( gl_prompt, -1, gl_mark );
|
|
gl_mark = tmp;
|
|
}
|