lafe/Makefile100444 325 24 4773 6215655317 11402 0ustar dlduser# $Id: Makefile,v 0.15 1996/09/12 00:34:00 dld Exp $ # # Makefile for lafe (Latency Free Empire) # # This makefile has specific clauses for target machines. If your machine # isn't listed, first try the "termcap" and "curses" machines. If these # don't work, add a clause with the necessary compile and link flags for # your machine, and send me an email. I hate #ifdefs in the code, and # struggle to eliminate them through compile/link flags. # GNU readline is in the readline/ directory, and uses a configure script. # It works (with the occaisional prod) on the machines I've used. YMMV. # Good luck debugging/porting it if your machine isn't a supported target # of readline. # # -Drake (harmless@empire.net) SHELL = /bin/sh SRC = lafe.c alias.c history.c parse.c var.c game.c OBJ = $(SRC:.c=.o) all: @echo "Chose one of the following architectures, or add a new entry to the Makefile:" @echo " termcap curses" @echo " irix irix6 aix solaris24 solaris25 osf1 linux" # # machine-specific targets # linux: CFLAGS='-g -I. -Dtparm=tgoto -DFNONBLOCK=O_NONBLOCK -DLINUX' LDFLAGS='-g' make termcap # the Irix 6 target uses the -32 flag to be runnable on Irix5 irix6: CFLAGS='-g -I. -32 -mips1' LDFLAGS='-g -32 -mips1' make termcap # should work on irix5 or irix6 irix: CFLAGS='-g -I.' LDFLAGS='-g' make termcap # should work on AIX3 or AIX4, posixy aix: CFLAGS='-g -I.' LDFLAGS='-g' make curses # another posixy unix, note the vanilla flags. osf1: CFLAGS='-g -I.' LDFLAGS='-g' make curses # not so posixy, weird libraries solaris24: CFLAGS='-g -I. -DHAVE_CONFIG_H' LDFLAGS='-g -lsocket -lnsl' make termcap solaris25: CFLAGS='-g -I.' LDFLAGS='-g -lsocket -lnsl' make termcap # # Internal lafe targets, CFLAGS and LDFLAGS won't get set if you call these termcap: configure $(OBJ) cd readline ; make $(CC) $(LDFLAGS) -o lafe $(OBJ) -Lreadline -lreadline -ltermcap curses: configure $(OBJ) cd readline ; make $(CC) $(LDFLAGS) -o lafe $(OBJ) -Lreadline -lreadline -lcurses configure: readline/config.status readline/config.status: cd readline ; CFLAGS='$(CFLAGS)' ./configure clean: -rm -f readline/core lafe *.o lafe.tar.gz example.tar.gz distclean: clean -cd readline ; make distclean dist: distclean cd .. ; tar cf - lafe/Makefile lafe/lafe.c lafe/lafe.h lafe/alias.c lafe/parse.c lafe/history.c lafe/var.c lafe/game.c lafe/README lafe/ChangeLog lafe/TODO lafe/example lafe/readline | gzip -9 >lafe/lafe.tar.gz cd .. ; tar cf - lafe/README lafe/example | gzip -9 > lafe/example.tar.gz lafe/lafe.c100444 325 24 46157 6215655151 11033 0ustar dlduserstatic char *RCSid="$Id: lafe.c,v 0.36 1996/09/12 00:32:17 dld Exp $"; char *LafeRevision="$Revision: 0.36 $"; /* Latency Free Empire This is a client optimized for high latency links. You can type in, edit, and send several commands before the server replies with output from the first command. This allows you to make better use of the existing bandwidth than most other clients. pei and eif are particularly susceptible to latency, as they require a complete exchange of data before prompting again. This could also be called LAg Free Empire. Empire 2 asynch features are supported. Empire 3 C_SYNC isn't supported yet, as this is a rather dumb client (in between emp_client and eif). Readline is supported, and at the moment required. If you want lafe without readline, use emp_client instead. -harmless@empire.net */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* include-file hell... I hate ifdefs... */ #if defined(LINUX) #include #include #else #include #include #endif #include #include #include "lafe.h" /* some defaults in case nothing is specified. Change as you wish. */ #define DEFPORT "7778" #define DEFHOST "empire.net" #define DEFCOUNTRY "visitor" #define DEFPASSWORD "visitor" int verbose=0; /************************************************************************ * The filedescriptor of the empire server socket. Had to make this * global in order to be accessible to event_hook(). * I always feel guilty when using globals... ************************************************************************/ int s=-1; /************************************************************************ * The stream pointer of the log file. Another global.. ************************************************************************/ FILE *log=NULL; /* process commands before sending to server on socket s. * handles aliases and local commands. Called by execute() and runfeed() * as well. */ extern void parse_command(char *); /* the length of the prompt. This plus rl_point is how far we have to go back to the beginning of the line. */ extern int rl_visible_prompt_length; /* I'm cheating by using these. */ extern int _rl_horizontal_scroll_mode; extern int _rl_vis_botlin, _rl_last_v_pos, _rl_last_c_pos; /* pointer to the readline prompt. This can change in the middle of * readline() if a prompt arrives in the middle of typing. */ extern char *rl_prompt,*rl_display_prompt; /************************************************************************ * Interrupt count, incremented each time an interrupt is received. ************************************************************************/ static int interrupts=0; void interrupt() { interrupts++; } /*************************************************************************** * A few routines to clear the readline-portion of the display. * Some initialization to get the necesary termcap strings and a * couple support routines. ***************************************************************************/ static char *tc_sc, *tc_rc, *tc_cd; /* save, restore, clear-to-eos */ static char *tc_LE, *tc_ce; static char *tc_ch, *tc_UP; static char *tc_so,*tc_se; /* highlighting on and off */ extern char *tgetstr(); /* for those systems that think putchar is a macro ... */ int putcharf(int c) { return putchar(c); } void init_tc() { static char *termstrbuf; char **area; /* SGI and IBM docs say area is meaningless under terminfo emulation, but it crashes without a sizeable buffer on the SGI... */ termstrbuf = malloc(2048); area = &termstrbuf; tgetent(termstrbuf,getenv("TERM")); tc_rc = tgetstr("rc",area); /* restore cursor */ tc_cd = tgetstr("cd",area); /* clear eos */ tc_sc = tgetstr("sc",area); /* save cursor */ tc_LE = tgetstr("LE",area); /* left #1 */ tc_ce = tgetstr("ce",area); /* clear to eol */ tc_ch = tgetstr("ch",area); /* set horzontal cursor position */ tc_UP = tgetstr("UP",area); /* up #1 */ tc_se = tgetstr("se",area); /* turn off highlighting */ tc_so = tgetstr("so",area); /* turn on highlighting */ /* this section is just for debugging termcap capabilities */ #if 0 if (tc_sc) fprintf(stderr,"tc: save cursor\n"); else fprintf(stderr,"tc: no save cursor\n"); if (tc_sc) fprintf(stderr,"tc: set horizontal cursor\n"); else fprintf(stderr,"tc: no set horizontal cursor\n"); if (tc_rc) fprintf(stderr,"tc: restore\n"); else fprintf(stderr,"tc: no restore\n"); if (tc_cd) fprintf(stderr,"tc: clear to end of screen\n"); else fprintf(stderr,"tc: no clear to end of screen\n"); if (tc_LE) fprintf(stderr,"tc: left param\n"); else fprintf(stderr,"tc: no left param\n"); if (tc_ce) fprintf(stderr,"tc: clear to end of line\n"); else fprintf(stderr,"tc: no clear to end of line\n"); #endif } /* move to left edge and clear to end */ void clear_readline() { if (tc_ch) { /* extra 0 added to tparm() so tgoto() can be used interchangeably */ tputs(tparm(tc_ch,0,0),1,putcharf); } else if (tc_LE) { tputs(tparm(tc_LE,_rl_last_c_pos,0),1,putcharf); } else if (tc_rc) { tputs(tc_rc,1,putcharf); } else { putcharf('\r'); } if (_rl_last_v_pos>0) { if (tc_UP) { tputs(tparm(tc_UP,_rl_last_v_pos,0),1,putcharf); } else { /* couldn't reach beginning, the display will look weird */ } } if (tc_cd) { tputs(tc_cd,1,putcharf); } else if (tc_ce) { tputs(tc_ce,1,putcharf); /* may not have cleared whole screen */ } else { printf("\n"); } } /* save position in case we need to clear */ void save_readline() { if (tc_sc) { tputs(tc_sc,1,putcharf); } } void quit() { exit(0); } /******************************************************** * Maximum number of commands on the output stack ********************************************************/ FILE *out=stdout; /* current prompt mode. Will be actual only if commands==0. */ char mode='\000'; static char *prompt=NULL; static int timeleft,btus,teles=0; /************************************************************ * Handle input lines depending on protocol number ************************************************************/ void process_line(char *buffer,int len) { int i,j,k; if (len<3) return; switch (buffer[0]) { case 'a': case '3': fwrite(buffer+2,1,len-2,out); if (log) fwrite(buffer+2,1,len-2,log); quit(); break; case '1': /* if out is the terminal, attempt to send highlighting codes */ if (out==stdout && tc_so && tc_se) { int i,lit=0; for (i=2;i3) { teles=1; sscanf(buffer+2,"%d new teles",&teles); putchar('\07'); /* BUG: prompt may not be a command prompt */ if (prompt) free(prompt); prompt=malloc(len+30); if (!commands) { sprintf(prompt,"%s [%d:%d] Command: ",buffer+2,timeleft,btus); } else { sprintf(prompt,"%s : ",buffer+2); } /* cheated a bit here again.. this isn't supposed to be allowed */ rl_display_prompt=rl_prompt=prompt; rl_visible_prompt_length = rl_expand_prompt(rl_prompt); } else { teles=0; } break; case '4': case '5': mode=buffer[0]; if (commands>1) { buffer[len-2]=0; fprintf(stdout,"%s %s\n",buffer+2,commandline[1]); if (log) fprintf(log,"%s %s\n",buffer+2,commandline[1]); } else { if (log) fwrite(buffer+2,1,len-3,log); } if (commands>0 && commandline[0]) { free(commandline[0]); } for (i=1;i0) commands--; if (prompt) free(prompt); prompt=malloc(len); memcpy(prompt,buffer+2,len-3); prompt[len-3]=' '; prompt[len-2]=0; if (!commands) { rl_display_prompt=rl_prompt=prompt; } else { rl_display_prompt=rl_prompt=": "; } rl_visible_prompt_length = rl_expand_prompt(rl_prompt); break; case '6': mode=buffer[0]; if (out!=stdout) { fclose(out); /* if pipe */ wait(NULL); } out=stdout; sscanf(buffer+2,"%d %d",&timeleft,&btus); if (commands>1) { fprintf(stdout,"[%d:%d] Command: %s\n",timeleft,btus,commandline[1]); if (log) fprintf(log,"[%d:%d] Command: %s\n",timeleft,btus,commandline[1]); } else { if (log) fprintf(log,"[%d:%d] Command: ",timeleft,btus); } if (commands>0 && commandline[0]) { free(commandline[0]); } for (i=1;i0) commands--; if (prompt) free(prompt); prompt=malloc(len+30); sprintf(prompt,"[%d:%d] Command: ",timeleft,btus); /* cheated a bit here again.. this isn't supposed to be allowed */ if (!commands) { rl_display_prompt=rl_prompt=prompt; } else { rl_display_prompt=rl_prompt=": "; } rl_visible_prompt_length = rl_expand_prompt(rl_prompt); break; case '8': for (i=2;(buffer[i]=='>') && i3) { out = fopen(buffer+j,"a"); } else { out = fopen(buffer+j,"w"); } if (!out) { perror("fopen"); out=stdout; } break; case '9': for (i=2;(buffer[i]=='|' || isspace(buffer[i])) && i1) { printf("Exitting on multiple interrupts\n"); exit(-1); } else if (interrupts) { write(s,"aborted\n",8); printf("^C\n"); } else { if (verbose) perror("select"); } } if (i>0) { interrupts=0; /* typing or receiving any data clears the interrupt count */ if (FD_ISSET(s,&in)) { int received=0; clear_readline(); fflush(rl_outstream); while ( (len=recv(s,buffer+offset,sizeof(buffer)-offset,0)) > 0) { received+=len; offset=output(buffer,len+offset); } if (received==0) { if (errno==ENOENT) printf("Lost connection to server\n"); else perror("recv"); quit(); } if (errno==EAGAIN) { /* no worries */ } else { perror("recv2"); quit(); } rl_forced_update_display(); } } } /*************************************************************************** * similar to event_hook. Keeps reading data until the connection is * resynchronized. Call before running a tool that needs complete data * (cmvr's and the like). ***************************************************************************/ void waitsync(char *dummy) { fd_set in; int i; int len; static char buffer[2048]; static int offset=0; /* unprocessed remnants in buffer */ while (commands>0) { /* wait for something from s */ FD_ZERO(&in); FD_SET(s,&in); i=select( FD_SETSIZE,&in,NULL,NULL,NULL); if (i<=0) { if (interrupts>1) { printf("Exitting on multiple interrupts\n"); exit(-1); } else if (interrupts) { write(s,"aborted\n",8); printf("^C\n"); } else { if (verbose) perror("select"); } } if (i>0) { interrupts=0; /* typing or receiving any data clears the interrupt count */ if (FD_ISSET(s,&in)) { int received=0; while ( (len=recv(s,buffer+offset,sizeof(buffer)-offset,0)) > 0) { received+=len; offset=output(buffer,len+offset); } if (received==0) { if (errno==ENOENT) printf("Lost connection to server\n"); else perror("recv"); quit(); } if (errno==EAGAIN) { /* no worries */ } else { perror("recv2"); quit(); } } } } } /************************************************************ * Open a socket to host/port and return filedescriptor. ************************************************************/ int empconnect(char *host,int port,char *user,char *country,char *pass) { struct hostent *hp; struct sockaddr_in sin; char buffer[1024]; if (isdigit(*host)) { sin.sin_addr.s_addr = inet_addr(host); } else { hp = gethostbyname(host); if (hp == NULL) { fprintf(stderr, "%s: No such host\n", host); return 0; } memcpy( &sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr)); } sin.sin_port = htons(port); s = socket(AF_INET, SOCK_STREAM, 0); if (s < 0) { perror("socket:"); return -1; } sin.sin_family = AF_INET; if (connect(s, &sin, sizeof(sin)) < 0) { perror("connect"); return -1; } fcntl(s,F_SETFL,FNONBLOCK); if (!user) user="nobody"; sprintf(buffer,"user %s\ncoun %s\npass %s\nclient lafe %s\nplay\n", user,country,pass,LafeRevision); write(s,buffer,strlen(buffer)); return s; } /*********************************************************************** * Set up readline() and socket s to server. Push each new line * down the socket. ***********************************************************************/ int main(int argc, char **argv) { char *line; char *host=NULL,*port=NULL,*country=NULL,*password=NULL,*logfile=NULL; rl_readline_name = argv[0]; rl_event_hook = (Function *)event_hook; rl_startup_hook = (Function *)save_readline; init_tc(); signal(SIGPIPE,SIG_IGN); /* don't worry if a destination pipe closes */ signal(SIGINT,interrupt); execute("~/.laferc"); if (argc>=5) { fprintf(stderr,"arguments may be visible\nmodifying your .laferc is the prefered method\n"); country=strdup(argv[1]); password=strdup(argv[2]); host=strdup(argv[3]); port=strdup(argv[4]); if (argc>5) logfile=strdup(argv[5]); else logfile=NULL; } else if (argc>=3) { fprintf(stderr,"arguments may be visible\nmodifying your .laferc is the prefered method\n"); country=strdup(argv[1]); password=strdup(argv[2]); host=getenv("EMPIREHOST"); port=getenv("EMPIREPORT"); if (argc>3) logfile=strdup(argv[3]); else logfile=NULL; } else if (argc==2) { int i; i = lookup_game(argv[1]); if (i>=0) { country = game[i].country; password = game[i].password; host = game[i].host; port = game[i].port; logfile = game[i].logfile; if (game[i].directory) { if (chdir(game[i].directory)) { perror(game[i].directory); } } } else { fprintf(stderr,"%s not found in addgame database. Edit ~/.laferc.\n", argv[1]); } } else if (argc==1) { fprintf(stderr,"environment variables may be visible\nmodifying your .laferc is the prefered method\n"); country=getenv("COUNTRY"); /* not advised for security reasons */ password=getenv("REPRESENTATIVE"); host=getenv("EMPIREHOST"); port=getenv("EMPIREPORT"); logfile=NULL; } else { fprintf(stderr,"Usage:\ \t%s host port country password [logfile]\n\ \t%s host port [logfile]\n\ \t%s [logfile]\n\ environment variables: EMPIREHOST EMPIREPORT COUNTRY REPRESENTATIVE\n", argv[0],argv[0],argv[0]); } if (!host) { host=DEFHOST; fprintf(stderr,"host defaulting to %s\n",host); } if (!port) { port=DEFPORT; fprintf(stderr,"port defaulting to %s\n",port); } if (!country) { country=DEFCOUNTRY; fprintf(stderr,"country defaulting to %s\n",country); } if (!password) { password=DEFPASSWORD; fprintf(stderr,"password defaulting to %s\n",password); } if (logfile) { log = fopen(logfile,"a"); if (!log) perror("log fopen"); } s=empconnect(host,atoi(port),getenv("USER"),country,password); if (s<0) { fprintf(stderr,"Unable to log in to %s at %s/%s\n",country,host,port); exit(-1); } /* clear command arguments. Doesn't work on all systems. */ { int i,j; for (i=0;i extern int command_stack; extern int commands; extern char **commandline; extern int s; /* server socket */ extern FILE *out; /* current redirection */ extern FILE *log; /* log file */ extern char mode; /* current prompt mode. Correct only if commands==0. */ extern int verbose; /* whether to spit out all the messages or not */ /* global routines in lafe */ extern char *expand_tilde(char *path); extern char *expand_alias(char *); extern char *getvar(char *); extern void putvar(char *,char *); extern char *expand_variables(char *); extern void parse_command(char *); extern void queue_command(char *); /* local commands */ extern void clearvar(char *); extern void setvar(char *); extern void history(char *); extern void alias(char *); extern void execute(char *); extern void runfeed(char *); extern void shell(char *); extern void help(char *); extern void addgame(char *); extern void verbosity(char *); extern void waitsync(char *); /* game database */ struct game { char *name; char *country; char *password; char *host; char *port; char *logfile; char *directory; }; extern int games; extern struct game *game; /* global routine in game.c */ int lookup_game(char *); lafe/alias.c100444 325 24 7603 6136663415 11172 0ustar dlduserstatic char *RCSid="$Id: alias.c,v 0.6 1996/04/22 11:01:32 dld Exp $"; /* alias.c * * Alias expansion and maintenance for lafe. */ #include #include #include "lafe.h" static int aliases=0; static char **key=NULL; /* alias names */ static char **value=NULL; /* alias definitions */ static int width=0; /* size of largest alias key */ static void print_aliases() { int i; for (i=0;i=0) { free(key[i]); free(value[i]); aliases--; key[i]=key[aliases]; value[i]=value[aliases]; } else { printf("%s not defined\n",name); } } static void define_alias(char *name,char *definition) { int i; int w; w=strlen(name); if (w>width) width=w; i=find_alias(name); if (i>=0) { free(value[i]); value[i]=strdup(definition); } else { key=realloc(key,(aliases+1) * sizeof(*key)); value=realloc(value,(aliases+1) * sizeof(*value)); key[aliases]=strdup(name); value[aliases]=strdup(definition); aliases++; } } /* alias expansion. Tokenizes arg and adds tokens to environment $1 $2 .... */ /* not finished */ static void tokenize(char *arg) { char *line; int start,end; char c,buffer[8]; int i; putvar("*",arg); /* put each fragment of arg into environment variables */ i=0; for (start=0;arg[start];start++) { if (!isspace(arg[start])) { for (end=start+1;arg[end] && !isspace(arg[end]);end++) ; c=arg[end]; arg[end]=0; sprintf(buffer,"%d",++i); putvar(buffer,arg+start); arg[end]=c; start=end; } } sprintf(buffer,"%d",++i); clearvar(buffer); } /* line must be individually malloced. If the alias is expanded, line will be freed by expand_alias, and a new line returned */ char *expand_alias(char *line) { int i,j,k; char *alias,*semi; for (i=0;line[i] && isspace(line[i]);i++) ; for (j=i;line[j] && !isspace(line[j]);j++) ; /* attempt to locate the alias index for this line */ { char c; c=line[j]; line[j]=0; k=find_alias(line+i); line[j]=c; } /* no alias found, so return line */ if (k<0) return line; /* expand ;'s in alias */ alias=strdup(value[k]); semi=strchr(alias,';'); while (semi) { *semi='\n'; semi=strchr(semi+1,';'); } /* advance j to next character */ for (;line[j] && isspace(line[j]);j++) ; /* if there are $'s in the alias, fill variables and return alias value */ if (strchr(alias,'$') || strchr(alias,'\n')) { tokenize(line+j); free(line); return alias; /* otherwise, replace the first word and append arguments */ } else { int len; char *newline; len=strlen(alias); newline=malloc(len+strlen(line+j)+2); strcpy(newline,alias); newline[len]=' '; strcpy(newline+len+1,line+j); free(line); free(alias); return newline; } } /* no arguments prints the alias database. * one argument delete the alias for that argument. * two arguments defines a new alias. */ void alias(char *line) { int i,j,k; char *name; i=0; /* print alias database */ if (!line || !*line) { print_aliases(); return; } /* alias name starts at i, ends at j. Def starts at k. */ /* get name of new or old alias */ for (j=i;line[j] && !isspace(line[j]);j++) ; /* skip whitespace */ for (k=j;line[k] && isspace(line[k]);k++) ; /* delete definition of name */ if (!line[k]) { line[j]=0; remove_alias(line+i); return; } line[j]=0; define_alias(line+i,line+k); } lafe/parse.c100444 325 24 14234 6215273070 11221 0ustar dlduserstatic char *RCSid="$Id: parse.c,v 0.14 1996/09/10 14:06:27 dld Exp $"; #include #include #include #include "lafe.h" int commands=0; int command_stack=0; char **commandline=NULL; /* replace a leading tilde by home directory */ char *expand_tilde(char *path) { int len; char *buffer; if (path && path[0]=='~') { len = strlen(getenv("HOME")) + strlen(path); buffer=malloc(len); sprintf(buffer,"%s%s",getenv("HOME"),path+1); free(path); return buffer; } else { return path; } } void verbosity(char *arg) { if (!strcmp("on",arg)) { verbose=1; } else if (!strcmp("off",arg)) { verbose=0; } else { verbose ^= 1; } if (verbose) printf("Verbose On\n"); else printf("Verbose Off\n"); } void shell(char *arg) { if (system(arg)) perror("system"); } /* lines limited to size of buffer. Shouldn't be much of a problem. */ void runfeed(char *arg) { FILE *pipe; char buffer[4096]; char *end; int fails=0; pipe = popen(arg,"r"); if (!pipe) { perror("popen"); return; } buffer[sizeof(buffer)-1]=0; while (fgets(buffer,sizeof(buffer)-1,pipe) != NULL) { end=strchr(buffer,'\n'); if (end) { *end = 0; parse_command(buffer); } else { fails++; } } if (fails) fprintf(stderr,"%d lines too long\n",fails); pclose(pipe); } void execute(char *arg) { FILE *fp; int i; char buffer[4096]; char *end; int fails=0; char *filename; buffer[sizeof(buffer)-1]=0; filename = strdup(arg); /* truncate anything past first argument */ for (i=0;filename[i] && !isspace(filename[i]);i++) ; filename[i]=0; /* expand a leading ~ into $HOME */ filename = expand_tilde(filename); fp = fopen(filename,"r"); if (!fp) { perror(filename); free(filename); return; } while (fgets(buffer,sizeof(buffer)-1,fp) != NULL) { end=strchr(buffer,'\n'); if (end) { *end = 0; parse_command(strdup(buffer)); } else { fails++; } } if (fails) fprintf(stderr,"%d lines too long\n",fails); fclose(fp); free(filename); } /************************************************************************** * parse commands. Look for commands matching local commands * and call the local handler. All others are sent directly to * the server on socket s. **************************************************************************/ struct local_command { char *name; /* command name .. "execute" */ int shortest; /* shortest abbreviation */ void (*process)(); /* function to parse arguments */ char *description; /* short description */ }; /* should be in alphabetical order */ static struct local_command local_command[] = { { "addgame", 7, addgame, "game country password host port logfile directory" }, { "alias", 5, alias, "[NAME [DEFINITION]]" }, { "execute", 4, execute, "FILENAME" }, { "help", 4, help, "" }, { "history", 4, history, "" }, { "runfeed", 7, runfeed, "SHELL_COMMAND" }, { "setvar", 4, setvar, "[NAME [VALUE]]" }, { "shell", 5, shell, "SHELL_COMMAND" }, { "verbose", 5, verbosity, "[on|off]" }, { "waitsync", 5, waitsync, "" } }; void help(char *dummy) { int i; extern char *LafeRevision; printf("\ \t\tLatency Free Empire\t\n\ \t\t %s\n\ \n\ \tusage: lafe [country [password [host [port]]]]\n\ \nlocal commands:\n",LafeRevision); for (i=0;i0 || mode=='6' || !mode) { line=expand_alias(line); line=expand_variables(line); } if (strchr(line,'\n')) { parse_command(line); } else { loc=pos=0; while (loc=local_command[loc].shortest) { int arg; /* position of arguments */ for (arg=pos;line[arg] && !isspace(line[arg]);arg++) ; for (;line[arg] && isspace(line[arg]);arg++) ; local_command[loc].process(line+arg); free(line); return; } } else if (line[start+pos] > local_command[loc].name[pos]) { loc++; pos=0; } else { break; } } } } /* no match found, send to server if connected to server */ if (s != -1) { len=strlen(line); line[len]='\n'; if (write(s,line,len+1) != len+1) { perror("command write failure"); } line[len]=0; if (!commands) { if (log) fprintf(log,"%s\n",line); } if (commands > command_stack-1) { if (!commandline) { command_stack=10; commandline=malloc(sizeof(*commandline)*command_stack); } else { command_stack *= 2; commandline = realloc(commandline,sizeof(*commandline)*command_stack); } } if (!commandline) { fprintf(stderr, "Memory allocation failure, commandlines lost\n"); command_stack=0; commands=0; free(line); } else { commandline[commands++]=line; } } else { if (verbose) fprintf(stderr,"# %s\n",line); free(line); } } lafe/history.c100444 325 24 513 6135052566 11551 0ustar dlduserstatic char *RCSid="$Id: history.c,v 0.1 1996/04/17 02:19:05 dld Exp $"; /* interface to the history library */ #include "readline/history.h" void history(char *line) { int i; HIST_ENTRY **entry; entry = history_list(); for (i=0;iline); } } lafe/var.c100444 325 24 6715 6215655007 10670 0ustar dlduserstatic char *RCSid="$Id: var.c,v 0.5 1996/09/12 00:30:39 dld Exp $"; /* var.c * * Variable expansion and maintenance. * * All variables are stored as enviroment variables. */ #include #include #include #include #include "lafe.h" static int variables=0; static char **key; static char **value; static int width=0; static int find_var(char *name) { int i; for (i=0;i=0) return value[i]; return NULL; } void putvar(char *name,char *val) { int i; i=find_var(name); if (i>=0) { free(value[i]); value[i]=strdup(val); } else { variables++; value=realloc(value,variables*sizeof(*value)); key=realloc(key,variables*sizeof(*key)); value[variables-1]=strdup(val); key[variables-1]=strdup(name); } i=strlen(name); if (i>width) width=i; } void clearvar(char *name) { int i; i=find_var(name); if (i>=0) { free(key[i]); free(value[i]); key[i]=key[variables-1]; value[i]=value[variables-1]; variables--; } } /* variable expansion, return a malloced line */ char *expand_variables(char *line) { char *oldline; int size; int src,dst,i; char *var,*val; /* exit fast if no $ in line */ /* if (!strchr(line,'$')) return line; */ oldline=line; size=256; line=malloc(size); if (!line) { perror("malloc"); return oldline; } for (src=dst=0;oldline[src];) { /* begining of a variable */ if (oldline[src] == '$') { /* allocate var to be the variable name */ /* a general {} variable */ if (oldline[++src]=='{') { for (i=(++src);oldline[i] && oldline[i]!='}';i++) ; var=malloc(i-src+1); strncpy(var,oldline+src,i-src); var[i-src]=0; src=i+1; /* a simple alphanumeric variable */ } else if (isalnum(oldline[src])) { for (i=src;isalnum(oldline[i]);i++) ; var=malloc(i-src+1); strncpy(var,oldline+src,i-src); var[i-src]=0; src=i; /* single character variable */ } else { var=malloc(2); var[0]=oldline[src]; var[1]=0; src++; } /* get value and copy into line at point dst */ val=getvar(var); if (!val) { if (verbose) fprintf(stderr,"%s not defined\n",var); } else { for (;*val;val++) { line[dst++] = *val; if (dst>=size-1) { line=realloc(line,size*=2); } } } free(var); /* everything between '' is returned verbatim, without the quotes. * needed to define aliases with runtime variables */ } else if (oldline[src]=='\'') { for (src++;oldline[src] && oldline[src]!='\'';src++) { line[dst++]=oldline[src]; if (dst>=size-1) { line=realloc(line,size*=2); } } if (oldline[src]) src++; /* copy character from src to dst */ } else { line[dst++]=oldline[src++]; if (dst>=size-1) { line=realloc(line,size*=2); } } } /* terminate string */ line[dst]=0; free(oldline); return line; } /* local commands to affect variables */ void setvar(char *line) { int i,j,k; for (i=0;line[i] && !isspace(line[i]);i++) ; if (!line[i]) { printvar(); return; } for (j=i;line[j] && isspace(line[j]);j++) ; line[i]=0; if (line[j]) putvar(line,line+j); else clearvar(line); } lafe/game.c100444 325 24 3676 6215247425 11015 0ustar dlduserstatic char *RCSid="$Id: game.c,v 1.5 1996/09/10 11:19:27 dld Exp $"; /************************************************************************* * parse the addgame command, and store in a database for later lookup *************************************************************************/ #include #include #include "lafe.h" struct game *game=NULL; int games=0; static char *token(char **str) { char *t=NULL; int i; while (**str && isspace(**str)) (*str)++; if (! **str) return NULL; if (**str=='"') { for (i=0;(*str)[i]!='"' && (*str)[i];i++) ; } else { for (i=0;!isspace( (*str)[i] ) && (*str)[i];i++) ; } t = malloc(i+1); strncpy(t,*str,i); t[i]=0; (*str) += i; if (**str) (*str)++; return t; } void addgame(char *arg) { if (!game) { game=malloc(sizeof(*game)); } else { game = realloc(game,(games+1)*sizeof(*game)); } memset(game+games,0,sizeof(*game)); game[games].name = token(&arg); if (game[games].name) { game[games].country = token(&arg); game[games].password = token(&arg); game[games].host = token(&arg); game[games].port = token(&arg); game[games].directory = expand_tilde(token(&arg)); game[games].logfile = expand_tilde(token(&arg)); if (game[games].country && game[games].password && game[games].host && game[games].port) { games++; } else { printf("addgame requires country password host and port parameters\n"); } } else { int i; for (i=0;i * Makefile: Added TODO and example.tar.gz to distribution targets * lafe.c: Redirections always in append mode. Counted > signs incorrectly.. * var.c: Permit single character non-alphanumeric variables. $* in particular. Only print "not defined" warnings if in verbose mode. Tue Sep 10 14:08:16 1996 Drake Diedrich * Makefile: example directory added to distribution target * lafe.h: interface definition to waitsync() local function * parse.c: Added waitsync local function. parse_command() checks for newlines after aliases expansion, and recalls itself if found. * lafe.c: Added waitsync command to resynchronize the server. Multi-line aliases weren't parsed multiple times by parse_command(). Fixed. Gross though, needs recoding. * example.laferc: Initial revision * lafe.h: define interface to expand_tilde() * parse.c: expand_tilde() function to expand a leading ~ into the $HOME directory. expand aliases and variables on every line of .laferc (mode==0) * lafe.c: mode defined to 0 when not connected. Only chdir() if directory is defined, print error on failure. * game.c: Swapped the position of the directory and logfile parameters to addgame. Fixed token() routine to handle missing tokens and lines with whitespace correctly. Expand ~ into home directory in logfile and directory. Directory and logfile are now optional, other parameters required. Tue Sep 10 03:26:45 1996 Drake Diedrich * lafe.c: type 'a' protocol fatal (bad password or country name). little changes to tparm and #includes for Linux. * Makefile: Added linux target. removed core in readline, readlines make distclean doesn't kill it Thu Sep 5 09:28:59 1996 Drake Diedrich * parse.c, lafe.h, lafe.c: Fixed logfile and long execs (prompt and Command: were confused). Thu Aug 22 11:13:55 1996 Drake Diedrich * parse.c: .laferc lines not malloc()ed, but free()d while parsing. Fixed. * lafe.c: memory freed from command stack even when commands==0. Check now. Wed Aug 21 08:32:38 1996 Drake Diedrich * lafe.c: Zeroed one character too early in pipes. Truncated last character. Mon Aug 19 10:09:26 1996 Drake Diedrich * README: verbose and addgame documentation. Eliminated the prompt fix message- didn't ever get around to it. Mon Aug 19 10:01:51 1996 Drake Diedrich * lafe.c: several optional outputs now depend on verbose flag: c_sync, select() errors, empire types 0,2,7,a, and b. Fixed handling of spaces in pipe command (would truncate rest of command). * lafe.h: Added verbose flag and verbosity() function to toggle it. * parse.c: Added verbose command to toggle verbose flag. Corrected arguments to addgame. * lafe.c: host/port/country/pass were unitialized, cause problems if "lafe game" not found in addgame database. Fri Aug 16 04:11:33 1996 Drake Diedrich * lafe.c: ^C sent abort\n, not aborted\n. Fixed. ^C should work now. Wed Aug 7 09:48:29 1996 Drake Diedrich * Makefile: Distinguished solaris 2.5 and solaris 2.4 targets. * game.c: changed bzero() to memset() for Solaris 2.4's sake. * lafe.c: addgame got logfile wrong (was same as port number) Wed Aug 7 07:33:42 1996 Drake Diedrich * game.c: RCS Id string added. * game.c: strcmp() arguments weren't both in the (). Why didn't SGI or IBM's compilers catch this? Shrug. Wed Aug 7 05:52:57 1996 Drake Diedrich * README: Documented "lafe game" syntax. * Makefile: Added game.c and example.laferc * parse.c: Test return value of popen. Inform user of failure. * lafe.c: Added tests to fopen and popen, failure informs user. * parse.c: addgame local command added. execute checks whether socket is valid before writing to it. Failure message if socket not open and unknown command is executed. * lafe.h: Added globals and routines in game.c * game.c: Initial revision * lafe.c: .laferc parsed before server connection opened. Don't try to strdup(getenv()).. crashes if variable not set. game[] lookup on single argument - all commandline options + directory Attempt to wipe out commandline arguments. Doesn't work on irix, maybe elsewhere? * lafe.c: Changed some fatal errors to non-fatal. Allows connection to 2.3.7 servers. Added a 5th argument, logfile. Optional. All output is appended to this file. * Makefile: Irix6.2 makes mips2 binaries by default. Change to mips1. (Bug in linker links mips2 libraries.. so it need to compile mips1 on a pre-6.2 machine anyway). Sigh. Sat Jul 6 02:35:12 1996 Drake Diedrich * parse.c: Make a copy of the execute argument, and modify the copy, not the original argument. Caused problems where "~/.laferc" was in read-only memory segment. * lafe.c: Made type 'a' a non-fatal error. So lafe works with 1.x/2.x servers (client command-not-found would abort lafe). Print out login sequence information. Wed May 8 07:39:50 1996 Drake Diedrich * parse.c: Really buggy, goes with lafe.c 0.21.1.1 * lafe.c: Really buggy. Aborting this one. Attempted to circularize the command buffer for inline synchs and such. Mon Apr 22 11:01:32 1996 Drake Diedrich * alias.c: Fixed argument assignments. * README: Updated for lafe-0.21. Local commands, .laferc and redirection. Mon Apr 22 06:45:03 1996 Drake Diedrich * alias.c: Format change in print_aliases(). * var.c: Format change in printvar(). * parse.c: Expand ~ into $HOME when executing a file. * lafe.c: execute ~/.laferc at startup. * alias.c: Replace ; with \n in alias expansions, for multiline aliases. * var.c: Removed some printfs expand_variables always runs whether $ present in line or not. Makes '' consistent. * lafe.c: mode = type of prompt received last. * lafe.h: *** empty log message *** * Makefile: Added lafe.h to distribution * parse.c: If there are newlines in the commandline, call parse_command for each line No interpretation done if line begins with \ Variable expansion after alias expansion. * var.c: Reimplemented independent of environment variables. They were buggy. * alias.c: Variable expansion added Fri Apr 19 01:35:36 1996 Drake Diedrich * alias.c: Modified the way local commands are called (only arguments are passed). * parse.c: Added mode sensitivity when commands==0. Does not expand prompt responses. Does not use commandline[] buffer if buffer overflow. Wed Apr 17 03:29:58 1996 Drake Diedrich * parse.c: Fixed extra newlines from execute() and runfeed(). * parse.c: Revised execute to use buffered I/O and call parse_command. Created several new local commands: help, runfeed, shell, history. Added descriptions to local commands (for help). parse_command() now calls expand_alias() on all lines. parse_command() calls local command routines with argument line, rather than full command line. execute() and runfeed may be sending extra newlines.. will check. * lafe.c: Removed command parser to it's own file (parse.c). Added a global LafeRevision to contain the version number of this file. Made socket and commandline[] global, so parse.c can access them. Removed execute() to parse.c * alias.c: Simple replacements of commands, no argument parsing yet. Mon Apr 15 02:22:25 1996 Drake Diedrich * lafe.c: Switched the order of parameters to match other clients. Country/pass always come first, follwed by optional host/port. Sends client ID to server now. Sat Feb 3 14:14:29 1996 Drake Diedrich * lafe.c: Leave spaces between two highlighted characters highlighted. Looks nicer and should print faster. * lafe.c: Added interrupt (abort) handling. * lafe.c: Added highlighting similar to the hack Ken sent me. I didn't touch readline though.. Thu Jan 25 23:49:52 1996 Drake Diedrich * Makefile: Added a comment about linking. Thu Jan 4 04:46:42 1996 Drake Diedrich * lafe.c: Treats command stack as a fifo, not a stack, when printing out prompts and commands. Thu Jan 4 03:01:03 1996 Drake Diedrich * lafe.c: Fixed typeahead prompt mixups (was always prompting with the last prompt received, even if several commands out of sync). * README: Updated README to cover commandline specifications and some compiling difficulties. * README: Comments about global termcap symbols. * Makefile: Added configure and OBJ prereqs to Solaris target. Wed Jan 3 23:55:49 1996 Drake Diedrich * lafe.c: Replaced putchar() with putcharf(), which calls putchar(). For SunOS's sake, where putchar() is a macro. Sun Dec 3 23:28:23 1995 Drake Diedrich * lafe.c: Added append mode for redirections. Sat Nov 25 08:31:50 1995 Drake Diedrich * Makefile: Added osf1 target. Added -9 to gzip for that extra 1%. * Makefile: Added solaris target (two extra libraries required) * lafe.c: Made server/country configurable. Parse commandline. Fixed command prompt printing (buffering screwed it up). Probably fixed a memory leak above as well. Change unknown prompt from "> " to ": " to avoid flash confusion. * README: Comments on portability. List known bugs. * lafe.tar.gz.info: Initial revision * lafe.c: Fixed a couple warnings. * README: Initial revision * Makefile: Added new targets for distribution. * lafe.c: A bunch of changes, comments lost when gaia's disk failed. Fortunately I'd copied this source file to empire.net first. Sat Nov 18 12:49:18 1995 Drake Diedrich * lafe.c: primitive exec implemented. Does no local parsing. blank lines crash the empire3 server (I'm hassling Ken to fix it at his end). File redirection needs to be stacked so that redirections within the exec file are local, not global. Fixed inform parsing and new tele message prompts. Empire3 is not sending [new tele] when an update occurs. * lafe.c: Fixed piping/readline conflict by putting a wait() right after the pipe close. Also waits after file close, but should return immediately as there are no child processes. Ignores SIGPIPE in case more closes prematurely. BUG: readline continues writing to stdout even if some other processes has been given stdout (more). Actually, I kind of like the blinking '>'.. * lafe.c: close() should have been fclose() in redirection section. Fixed whitespace removal in both redirection and piping. BUG: need to fix readline prompt after piping. * lafe.c: new tele messages supported with rl_message() custom prompts (type 4) implemented as command prompts command prompt modified to look like emp_client prompt BUGS: redirection and piping don't work. exec is unimplemented. * lafe.c: Fixed the command prompt, the readline prompt is now overwritten by resetting rl_display_prompt=rl_prompt=prompt. There may be a memory leak now.. will look for it. * lafe.c: Fixed buffering problem that led to lost data and tracking failures (unimplemented protocol errors). * Makefile: Fixed dependencies so lafe compiles. * Makefile: Initial version * lafe.c: *** empty log message *** lafe/TODO100444 325 24 2547 6215417674 10431 0ustar dlduserThings to do to lafe: Append mode. Done. EmpireToolKit. Cancelled. history mechanism. Partial. configuration file. Done. symmetric processing of execs and commandline input. Done. Single : prompt not shown when several commands typed in ahead and a new prompt arrives. Fixed. Local commands. Done. Runfeed. Done. Help. Done. Aliases. Done. Variables. Done. Multi-line aliases. Done. Unconditional send-to-server (to avoid aliases). Done. Don't alias if at a sub-prompt. Done. Need to wait for return input if command buffer overflows. Cancelled. Crashes on long execs. Fixed. Command prompts are screwed up when receiving old data. Fixed? Distinguishing and resyncing on subprompt, prompt, and local commands. Cancel. Arguments to exec. Cancel. Flash/Inform messages at sub-prompt screw up prompt (uses Command:) Done. syncwait command, wait for synchronization with server. Done. linux changes to Makefile/source. Done. make .laferc addgame compatible with pei's addgame command. connect should fail if no such country. Done. malloc failure reported.. long motd and SIGWINCH involved. Redirection on local commands. Recursive redirections are busted. multiple host connections. Binary instead of linear searches on variables and aliases. C_SYNC forwarding. game-specific after-.laferc script, can include empire commands. variable? autostart hub- can almost do? lafe/example/ 40755 325 24 0 6215407170 11257 5ustar dlduserlafe/example/example.laferc100444 325 24 11240 6215407170 14201 0ustar dlduser# $Id: example.laferc,v 1.3 1996/09/11 00:56:02 dld Exp $ # # Install in your home directory with name .laferc # Modify with you own aliases and game information (country, password,...) # Make sure it's only readable by yourself if you don't want your passwords # known to others on your system. # cp example.laferc ~/.laferc # emacs ~/.laferc # chmod go-r .laferc # # Used for debugging and looking at C_SYNC. # verbose on # aliases with no runtime variables may be expanded early without quotes # alises with runtimes ($1,$2,$*,...) must be enclosed in single quotes ('') # # typos I make often # alias threhs thresh alias res reso # # Example of a program (delta) that needs data before run. waitsync won't # return until the server has no more data to send # alias delta 'cen * >.delta ; com * >>.delta ; prod * >>.delta ; waitsync ; shell delta .delta' alias cdelta 'cen * >.cdelta ; prod * >>.cdelta ; waitsync; shell delta .cdelta' # # Multi-line aliases with variable expansion # Stolen from example.peirc (in the pei distribution) # Set thresholds: alias thom 'th o * ?newd=o 1; th i * ?newd=m 1; th d * ?newd=g 1; th l * ?newd=j 1; th h * ?newd=k 1; th s * ?newd=i 1; th g * ?newd=d 1; th p * ?newd=% 1; th r * ?newd=u 1' # Build a bridge and explore onto it: alias bb 'build b $1 $2 ; expl c $1 1 $2 ; ' # fire alias fi 'fire sect $1 $2' alias fl 'fire land $1 $2' alias fs 'fire ship $1 $2' # machine-gun fire alias mfi 'fi $1 $2 ; fi $1 $2 ; fi $1 $2 ; fi $1 $2 ; fi $1 $2 ; fi $1 $2 ; fi $1 $2 ; fi $1 $2 ' alias mfl 'fl $1 $2 ; fl $1 $2 ; fl $1 $2 ; fl $1 $2 ; fl $1 $2 ; fl $1 $2 ; fl $1 $2 ; fl $1 $2 ' alias mfs 'fs $1 $2 ; fs $1 $2 ; fs $1 $2 ; fs $1 $2 ; fs $1 $2 ; fs $1 $2 ; fs $1 $2 ; fs $1 $2 ' # Production of interesting sectors: alias pr 'prod * ?newd#m&newd#g&newd#o&newd#a&newd#+' # Pipe info pages to more: alias info 'info $1 | more' # Move commodities out of sectors they shouldn't be in: alias thod 'th i * ?iron>1&newd#j&newd#k&newd#w 1; th o * ?oil>1&newd#%&newd#d&newd#t&newd#r&newd#w 1; th d * ?dust>1&newd#b&newd#t&newd#r&newd#w 1; th l * ?lcm>1&newd#h&newd#*&newd#!&newd#t&newd#r&newd#i&newd#d&newd#l&newd#p&newd#w 1; th h * ?hcm>1&newd#h&newd#*&newd#!&newd#i&newd#d&newd#w 1; th b * ?bar>1&newd#b&newd#w 1; th d * ?newd=b&bar=999 1' # # Several blitz games defined using variables # Only directory is specified, there is no logfile for these. # setvar WOLFDIR ~/emp/wolf setvar VAMPIREHOST idiot.alfred.edu setvar VAMPIREPORT 6667 addgame v1 1 1 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v2 2 2 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v3 3 3 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v4 4 4 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v5 5 5 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v6 6 6 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v7 7 7 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v8 8 8 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v9 9 9 $VAMPIREHOST $VAMPIREPORT $WOLFDIR addgame v10 10 10 $VAMPIREHOST $VAMPIREPORT $WOLFDIR setvar CHEETAHHOST empire.net setvar CHEETAHPORT 6667 addgame c1 1 1 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c2 2 2 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c3 3 3 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c4 4 4 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c5 5 5 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c6 6 6 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c7 7 7 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c8 8 8 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c9 9 9 $CHEETAHHOST $CHEETAHPORT $WOLFDIR addgame c10 10 10 $CHEETAHHOST $CHEETAHPORT $WOLFDIR setvar HOWITZERDIR ~/emp/how setvar HOWITZERHOST empire.net setvar HOWITZERPORT 7778 addgame h1 1 1 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h2 2 2 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h3 3 3 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h4 4 4 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h5 5 5 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h6 6 6 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h7 7 7 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h8 8 8 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h9 9 9 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR addgame h10 10 10 $HOWITZERHOST $HOWITZERPORT $HOWITZERDIR # visitor accounts, no directory or logfile addgame hv visitor visitor empire.net 7778 addgame bv visitor visitor measun10.city.ac.uk 7778 addgame gv Visitor visitor isumataq.eskimo.com 13715 addgame vv visitor visitor idiot.alfred.edu 6667 addgame cv visitor visitor empire.net 6667 # a long term game # routed to a localhost where an empirehub is running, # connecting to dork.alfred.edu/3777, listening to 3777 on valera # all transactions will be stored in ~/emp/mini/log addgame mini harmless DntUWsh localhost 3777 ~/emp/mini log lafe/example/RCS120755 325 24 0 6215251621 12761 2../RCSexustar dlduserlafe/example/scuttle100644 325 24 427 6215252560 12746 0ustar dldusernav S ?xloc=-35&yloc=11&type=ts2 -36,12 scuttle ship 34,22 ?type=ts2&eff=100 y scuttle ship -17,19 ?type=ts2&eff=100 y scuttle ship 42,-22 ?type=ts2&eff=100 y scuttle ship -36,12 ?type=ts2&eff=100 y scuttle ship 22,12 ?type=ts2&eff=100 y scuttle ship -46,20 ?type=ts2&eff=100 y lafe/example/delta100755 325 24 12715 6215257124 12423 0ustar dlduser#!/bin/awk -f # # delta # # written by Ken Stevens for chainsaw 3.0 # # DESCRIPTION: # This script reads through your production info and tells you whether you # have a positive or negative delta on iron, dust, lcm, etc... # I find it useful for balancing production in large economies. # The output looks something like this: # # ----PRODUCTION DELTA REPORT---- # com start + - delta net # ---------------------------------------------------- # food 882 857 267 589 1471 # iron 719 466 575 -109 610 # oil 78 27 20 7 85 # dust 121 102 79 23 144 # lcm 228 216 116 100 328 # ---------------------------------------------------- # bars 5 15 20 # mil 130 156 286 # # INSTALLATION: # Before you run this script, make sure that you have typed: # chmod +x delta # where delta is the name of this file. # # HOW TO RUN IT: # Set the variable MAX_CIV_PER_SECTOR to what the "nation" command tells you # your max civs per sector is. (This variable is set at the top of # the script, just a few lines below here.) # # If you use eif, then you should just put the following two lines in # your .eifrc file: # # alias del "cen # >!.delta ; com # >>.delta ; prod # >>.delta ; @delta .delta" # alias cdel "cen # >!.cdelta ; prod # >>.cdelta ; @delta .cdelta" # # Then in eif you can type "del" to get your production delta. The extra # feature "cdel" tells you approximately how many updates until your civs # max out. # # If you don't use eif, then all I have to say is "you should". But I # may be biased, because my cousin wrote it. # # BUG REPORTS: # mail your bug-reports and comments to: # stevens@math.utoronto.ca BEGIN { MAX_CIV_PER_SECTOR = 558; if (etu=="") etu=60; if (maxpop=="") maxpop=550; } function num(str) { return substr(str,1,length(str)-1); } { if ($5 != "1993" && $1 != "sect") { if (com) { { ss += $5; sg += $6; sp += $7; si += $8; sd += $9; sb += $10; so += $11; sl += $12; sh += $13; sr += $14; } } else if (prod) { if ($2 == "m") {i += $5} if ($2 == "g") {d += $5} if ($2 == "o") {o += $5} if ($2 == "%") {p += $5; oc += num($9)} if ($2 == "j") {l += $5; ic += num($9)} if ($2 == "k") {h += $5; ic += num($9)} if ($2 == "l") {lc += num($9)} if ($2 == "b") {b += $5; dc += num($9)} if ($2 == "i") {s += $5; lc += num($9); hc += num($10)} if ($2 == "d") {g += $5; oc += num($9); lc += num($10); hc += ($11)} if ($2 == "t") {dc += num($9); oc += num($10); lc += num($11)} if ($2 == "r") {dc += num($9); oc += num($10); lc += num($11)} if ($2 == "e") {m += $5} if ($2 == "a") {f += $5} if ($2 == "^") {mountain += 1} } else if (cen) { if ($7 == "*") { sc += $8; sm += $9; su += $10; sf += $11; } else { sc += $7; sm += $8; su += $9; sf += $10; } } } } /CENSUS/ {cen = 1; com = 0; prod = 0; } /COMMODITIES/ {com = 1; cen = 0; prod = 0; do_delta = 1; } /PRODUCTION/ {prod = 1; cen = 0; com = 0; } /sectors/ {if (cen) sectors = $1; } END { if (do_delta) { c = sc*etu*5/1000; u = su*etu*2.5/1000; fc += ((sc+sm+su)*etu/1000)+((c+u)*12/1000); print " ----PRODUCTION DELTA REPORT----"; printf "%5s %8s %8s %8s %8s %8s\n", "com","start", "+", "-", "delta", "net"; print "----------------------------------------------------"; if (f||fc) {printf "%5s %8d %8d %8d %8d %8d\n", "food", sf, f, fc, f-fc, sf+f-fc} if (i||si) {printf "%5s %8d %8d %8d %8d %8d\n", "iron", si, i, ic, i-ic, si+i-ic} if (o||so) {printf "%5s %8d %8d %8d %8d %8d\n", "oil", so, o, oc, o-oc, so+o-oc} if (d||sd) {printf "%5s %8d %8d %8d %8d %8d\n", "dust", sd, d, dc, d-dc, sd+d-dc} if (l||sl) {printf "%5s %8d %8d %8d %8d %8d\n", "lcm", sl, l, lc, l-lc, sl+l-lc} if (h||sh) {printf "%5s %8d %8d %8d %8d %8d\n", "hcm", sh, h, hc, h-hc, sh+h-hc} print "----------------------------------------------------"; if (b||sb) {printf "%5s %8d %8d %8s %8s %8d\n", "bars", sb, b, "", "", sb+b} if (p||sp) {printf "%5s %8d %8d %8s %8s %8d\n", "pet", sp, p, "", "", sp+p} if (s||ss) {printf "%5s %8d %8d %8s %8s %8d\n", "shell", ss, s, "", "", ss+s} if (g||sg) {printf "%5s %8d %8d %8s %8s %8d\n", "guns", sg, g, "", "", sg+g} if (c||sc) {printf "%5s %8d %8d %8s %8s %8d\n", "civ", sc, c, "", "", sc+c} if (u||su) {printf "%5s %8d %8d %8s %8s %8d\n", "uw", su, u, "", "", su+u} if (m||sm) {printf "%5s %8d %8d %8s %8s %8d\n", "mil", sm, m, "", "", sm+m} } else { sectors -= mountains; civmax = sectors*maxpop; civ = sc + sm; uw = su; foo = sf; fprod = f; print " ----FOOD DELTA REPORT----"; print " start food food food"; print "update food civ uw eaten prod delta"; print "-------------------------------------------------------"; for (i = 1; i <= 10; ++i) { cbaby = civ*etu*5/1000 ubaby = uw*etu*2.5/1000; eaten = ((civ+uw)*etu/1000)+((cbaby+ubaby)*12/1000); delta = fprod - eaten; printf " %2d:\t%6d\t%6d\t%6d\t%6d\t%6d\t%6d\n", i, foo, civ, uw, eaten, fprod, delta; foo += delta; civ += cbaby; if (civ > civmax) {civ = civmax} uw += ubaby; } printf "Maximum civs for %d sectors: %d\n", sectors, civmax; } } lafe/example/order100644 325 24 3636 6215252562 12425 0ustar dlduserfleet S ~ ?xloc=15&yloc=-3&type=ts2&civ=50&autonav=0&food>0 fleet S ~ ?xloc=14&yloc=-2&type=ts2&civ=50&autonav=0&food>0 fleet S ~ ?xloc=4&yloc=-4&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=9&yloc=5&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=4&yloc=4&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=1&yloc=3&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=-2&yloc=0&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=-5&yloc=-5&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=-5&yloc=-3&type=ts2&civ=50&autonav=0&food>0 fleet O ~ ?xloc=0&yloc=2&type=ts2&civ=50&autonav=0&food>0 fleet C ~ ?xloc=-5&yloc=-1&type=ts2&civ=50&autonav=0&food>0 fleet C ~ ?xloc=-6&yloc=-2&type=ts2&civ=50&autonav=0&food>0 fleet C ~ ?xloc=-7&yloc=-3&type=ts2&civ=50&autonav=0&food>0 fleet C ~ ?xloc=-8&yloc=-4&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=-4&yloc=-2&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=20&yloc=-2&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=19&yloc=-5&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=16&yloc=0&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=26&yloc=-2&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=2&yloc=-4&type=ts2&civ=50&autonav=0&food>0 fleet L ~ ?xloc=5&yloc=-3&type=ts2&civ=50&autonav=0&food>0 fleet X ~ ?xloc=-23&yloc=-7&type=ts2&civ=50&autonav=0&food>0 fleet X ~ ?xloc=-22&yloc=-8&type=ts2&civ=50&autonav=0&food>0 fleet X ~ ?xloc=-25&yloc=-7&type=ts2&civ=50&autonav=0&food>0 fleet A ~ ?xloc=14&yloc=2&type=ts2&civ=50&autonav=0&food>0 order C d 34,22 - order L d -17,19 - order O d 42,-22 - order S d -36,12 - order X d 22,12 - order A d -46,20 - order S ?xloc=14&yloc=-2&type=ts2&civ=50&autonav#0&food>0 d -6,-2 - order S ?xloc=15&yloc=-3&type=ts2&civ=50&autonav#0&food>0 d -6,-2 - order S ?xloc=4&yloc=-4&type=ts2&civ=50&autonav#0&food>0 d -6,-2 - order L ?xloc=20&yloc=-2&type=ts2&civ=50&autonav#0&food>0 d -11,-1 - order L ?xloc=19&yloc=-5&type=ts2&civ=50&autonav#0&food>0 d -11,-1 - lafe/example/build100644 325 24 313 6215253637 12362 0ustar dlduserbuild sh * ?des=h&avail>83&lcm>39&hcm>19 ts2 build sh * ?des=h&avail>503&lcm>239&hcm>119 ts2 2 build sh * ?des=h&avail>923&lcm>439&hcm>219 ts2 3 load c ~ ?type=ts2&civ=0 50 load f ~ ?type=ts2&food=0 10 lafe/example/nocap100644 325 24 42 6215252600 12327 0ustar dlduserdes 22,-4 c cap 22,-4 des 22,-4 + lafe/example/README100644 325 24 1663 6215272534 12246 0ustar dlduserexample.laferc A sample .laferc. Game connectivity info and common aliases are defined here. Customize to your liking and copy into your home directory as .laferc. nocap A sample exec script that fluxes your cap (so it can't be sacked). Assumes sector 22,-4 is less that 5% efficient. build Build and load trade ships in harbors with lots of avail. Not a smart script, it overbuilds. Be sure to build your warships first. order An example exec script to assign sailing orders to trade ships based on origin. Puts each destination in a separate fleet, and assigns temporary orders to route around hazards. scuttle An example exec script to nav trade ships the last bit to destination harbors, and scuttle 100% trade ships once there. delta A simple awk script that adds up the use and production columns in a production report. Place on your execution path or in a game directory. Needs updating to newer servers. lafe/example/build~100644 325 24 457 6215252563 12566 0ustar dlduserbuild sh 2,-4 ts2 20 build sh 5,-3 ts2 20 build sh * ?des=h&avail>43&avail<221&lcm>39 ts2 build sh * ?des=h&avail>220&avail<441&lcm>239 ts2 2 build sh * ?des=h&avail>440&avail<661&lcm>439 ts2 3 build sh * ?des=h&avail>660&avail<881&lcm>639 ts2 4 load c ~ ?type=ts2&civ=0 50 load f ~ ?type=ts2&food=0 2 lafe/example/README~100644 325 24 1370 6215255320 12431 0ustar dlduserexample.laferc A sample .laferc. Game connectivity info and common aliases are defined here. Customize to your liking and copy into your home directory as .laferc. nocap A sample exec script that fluxes your cap (so it can't be sacked). Assumes sector 22,-4 is less that 5% efficient. build Build and load trade ships in harbors with lots of avail. Not a smart script, it overbuilds. Be sure to build your warships first. order An example exec script to assign sailing orders to trade ships based on origin. Puts each destination in a separate fleet, and assigns temporary orders to route around hazards. scuttle An example exec script to nav trade ships the last bit to destination harbors, and scuttle 100% trade ships once there. lafe/readline/ 40700 325 24 0 6215656373 11410 5ustar dlduserlafe/readline/RCS/ 40755 325 24 0 6106101040 12020 5ustar dlduserlafe/readline/RCS/readline.c,v100444 325 24 234606 6106101040 14357 0ustar dlduserhead 1.2; access; symbols; locks dld:1.2 dld:1.1; strict; comment @ * @; 1.2 date 95.11.25.06.23.37; author dld; state Exp; branches; next 1.1; 1.1 date 95.11.25.05.06.46; author dld; state Exp; branches; next ; desc @@ 1.2 log @#ifdef'd out extern (BC,UP) unless an SGI @ text @/* readline.c -- a general facility for reading lines of input with emacs style editing and completion. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #if !defined (NO_SYS_FILE) # include #endif /* !NO_SYS_FILE */ #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" #if defined (GWINSZ_IN_SYS_IOCTL) || (defined (VSTATUS) && !defined (SunOS4)) # include #endif /* GWINSZ_IN_SYS_IOCTL || VSTATUS */ /* Some standard library routines. */ #include "readline.h" #include "history.h" /* NOTE: Functions and variables prefixed with `_rl_' are pseudo-global: they are global so they can be shared between files in the readline library, but are not intended to be visible to readline callers. */ /* Functions imported from other files in the library. */ extern char *tgetstr (); extern void rl_prep_terminal (), rl_deprep_terminal (); extern void _rl_bind_if_unbound (); /* External redisplay functions and variables from display.c */ extern void _rl_move_vert (); extern void _rl_update_final (); extern void _rl_erase_at_end_of_line (); extern void _rl_move_cursor_relative (); extern int _rl_vis_botlin; extern int _rl_last_c_pos; extern int _rl_horizontal_scroll_mode; extern int rl_display_fixed; extern char *rl_display_prompt; /* Variables imported from complete.c. */ extern char *rl_completer_word_break_characters; extern char *rl_basic_word_break_characters; extern int rl_completion_query_items; extern int rl_complete_with_tilde_expansion; #if defined (VI_MODE) extern void _rl_vi_set_last (); extern void _rl_vi_reset_last (); extern void _rl_vi_done_inserting (); #endif /* VI_MODE */ /* Forward declarations used in this file. */ void _rl_free_history_entry (); int _rl_dispatch (); void _rl_set_screen_size (); int _rl_output_character_function (); static char *readline_internal (); static void readline_initialize_everything (); static int init_terminal_io (); static void start_using_history (); static void bind_arrow_keys (); #if !defined (__GO32__) static void readline_default_bindings (); #endif /* !__GO32__ */ #if defined (__GO32__) # include # undef HANDLE_SIGNALS #endif /* __GO32__ */ #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Line editing input utility */ /* */ /* **************************************************************** */ static char *LibraryVersion = "2.0"; /* A pointer to the keymap that is currently in use. By default, it is the standard emacs keymap. */ Keymap _rl_keymap = emacs_standard_keymap; /* The current style of editing. */ int rl_editing_mode = emacs_mode; /* Non-zero if the previous command was a kill command. */ static int last_command_was_kill = 0; /* The current value of the numeric argument specified by the user. */ int rl_numeric_arg = 1; /* Non-zero if an argument was typed. */ int rl_explicit_arg = 0; /* Temporary value used while generating the argument. */ int rl_arg_sign = 1; /* Non-zero means we have been called at least once before. */ static int rl_initialized = 0; /* If non-zero, this program is running in an EMACS buffer. */ static int running_in_emacs = 0; /* The current offset in the current input line. */ int rl_point; /* Mark in the current input line. */ int rl_mark; /* Length of the current input line. */ int rl_end; /* Make this non-zero to return the current input_line. */ int rl_done; /* The last function executed by readline. */ Function *rl_last_func = (Function *)NULL; /* Top level environment for readline_internal (). */ static jmp_buf readline_top_level; /* The streams we interact with. */ static FILE *in_stream, *out_stream; /* The names of the streams that we do input and output to. */ FILE *rl_instream = (FILE *)NULL; FILE *rl_outstream = (FILE *)NULL; /* Non-zero means echo characters as they are read. */ int readline_echoing_p = 1; /* Current prompt. */ char *rl_prompt; int rl_visible_prompt_length = 0; /* The number of characters read in order to type this complete command. */ int rl_key_sequence_length = 0; /* If non-zero, then this is the address of a function to call just before readline_internal () prints the first prompt. */ Function *rl_startup_hook = (Function *)NULL; /* What we use internally. You should always refer to RL_LINE_BUFFER. */ static char *the_line; /* The character that can generate an EOF. Really read from the terminal driver... just defaulted here. */ int _rl_eof_char = CTRL ('D'); /* Non-zero makes this the next keystroke to read. */ int rl_pending_input = 0; /* Pointer to a useful terminal name. */ char *rl_terminal_name = (char *)NULL; /* Non-zero means to always use horizontal scrolling in line display. */ int _rl_horizontal_scroll_mode = 0; /* Non-zero means to display an asterisk at the starts of history lines which have been modified. */ int _rl_mark_modified_lines = 0; /* The style of `bell' notification preferred. This can be set to NO_BELL, AUDIBLE_BELL, or VISIBLE_BELL. */ int _rl_bell_preference = AUDIBLE_BELL; /* Line buffer and maintenence. */ char *rl_line_buffer = (char *)NULL; int rl_line_buffer_len = 0; #define DEFAULT_BUFFER_SIZE 256 /* Forward declarations used by the display and termcap code. */ int term_xn; int screenwidth, screenheight, screenchars; /* **************************************************************** */ /* */ /* `Forward' declarations */ /* */ /* **************************************************************** */ /* Non-zero means do not parse any lines other than comments and parser directives. */ unsigned char _rl_parsing_conditionalized_out = 0; /* Non-zero means to save keys that we dispatch on in a kbd macro. */ static int defining_kbd_macro = 0; /* Non-zero means to convert characters with the meta bit set to escape-prefixed characters so we can indirect through emacs_meta_keymap or vi_escape_keymap. */ int _rl_convert_meta_chars_to_ascii = 1; /* Non-zero means to output characters with the meta bit set directly rather than as a meta-prefixed escape sequence. */ int _rl_output_meta_chars = 0; /* Non-zero tells rl_delete_text and rl_insert_text to not add to the undo list. */ static int doing_an_undo = 0; /* **************************************************************** */ /* */ /* Top Level Functions */ /* */ /* **************************************************************** */ /* Non-zero means treat 0200 bit in terminal input as Meta bit. */ int _rl_meta_flag = 0; /* Forward declaration */ /* Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. A return value of NULL means that EOF was encountered. */ char * readline (prompt) char *prompt; { char *value; rl_prompt = prompt; /* If we are at EOF return a NULL string. */ if (rl_pending_input == EOF) { rl_pending_input = 0; return ((char *)NULL); } rl_visible_prompt_length = rl_expand_prompt (rl_prompt); rl_initialize (); rl_prep_terminal (_rl_meta_flag); #if defined (HANDLE_SIGNALS) rl_set_signals (); #endif value = readline_internal (); rl_deprep_terminal (); #if defined (HANDLE_SIGNALS) rl_clear_signals (); #endif return (value); } /* Read a line of input from the global rl_instream, doing output on the global rl_outstream. If rl_prompt is non-null, then that is our prompt. */ static char * readline_internal () { int lastc, c, eof_found; in_stream = rl_instream; out_stream = rl_outstream; lastc = -1; eof_found = 0; if (rl_startup_hook) (*rl_startup_hook) (); if (!readline_echoing_p) { if (rl_prompt) { fprintf (out_stream, "%s", rl_prompt); fflush (out_stream); } } else { rl_on_new_line (); rl_redisplay (); #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_vi_insertion_mode (); #endif /* VI_MODE */ } while (!rl_done) { int lk = last_command_was_kill; int code; code = setjmp (readline_top_level); if (code) rl_redisplay (); if (!rl_pending_input) { /* Then initialize the argument and number of keys read. */ rl_init_argument (); rl_key_sequence_length = 0; } c = rl_read_key (); /* EOF typed to a non-blank line is a . */ if (c == EOF && rl_end) c = NEWLINE; /* The character _rl_eof_char typed to blank line, and not as the previous character is interpreted as EOF. */ if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end) { eof_found = 1; break; } lastc = c; _rl_dispatch (c, _rl_keymap); /* If there was no change in last_command_was_kill, then no kill has taken place. Note that if input is pending we are reading a prefix command, so nothing has changed yet. */ if (!rl_pending_input) { if (lk == last_command_was_kill) last_command_was_kill = 0; } #if defined (VI_MODE) /* In vi mode, when you exit insert mode, the cursor moves back over the previous character. We explicitly check for that here. */ if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap) rl_vi_check (); #endif /* VI_MODE */ if (!rl_done) rl_redisplay (); } /* Restore the original of this history line, iff the line that we are editing was originally in the history, AND the line has changed. */ { HIST_ENTRY *entry = current_history (); if (entry && rl_undo_list) { char *temp = savestring (the_line); rl_revert_line (); entry = replace_history_entry (where_history (), the_line, (HIST_ENTRY *)NULL); _rl_free_history_entry (entry); strcpy (the_line, temp); free (temp); } } /* At any rate, it is highly likely that this line has an undo list. Get rid of it now. */ if (rl_undo_list) free_undo_list (); if (eof_found) return (char *)NULL; else return (savestring (the_line)); } /* **************************************************************** */ /* */ /* Character Input Buffering */ /* */ /* **************************************************************** */ static int pop_index = 0, push_index = 0, ibuffer_len = 511; static unsigned char ibuffer[512]; /* Non-null means it is a pointer to a function to run while waiting for character input. */ Function *rl_event_hook = (Function *)NULL; #define any_typein (push_index != pop_index) /* Add KEY to the buffer of characters to be read. */ rl_stuff_char (key) int key; { if (key == EOF) { key = NEWLINE; rl_pending_input = EOF; } ibuffer[push_index++] = key; if (push_index >= ibuffer_len) push_index = 0; return push_index; } /* Return the amount of space available in the buffer for stuffing characters. */ int ibuffer_space () { if (pop_index > push_index) return (pop_index - push_index); else return (ibuffer_len - (push_index - pop_index)); } /* Get a key from the buffer of characters to be read. Return the key in KEY. Result is KEY if there was a key, or 0 if there wasn't. */ int rl_get_char (key) int *key; { if (push_index == pop_index) return (0); *key = ibuffer[pop_index++]; if (pop_index >= ibuffer_len) pop_index = 0; return (1); } /* Stuff KEY into the *front* of the input buffer. Returns non-zero if successful, zero if there is no space left in the buffer. */ int rl_unget_char (key) int key; { if (ibuffer_space ()) { pop_index--; if (pop_index < 0) pop_index = ibuffer_len - 1; ibuffer[pop_index] = key; return (1); } return (0); } /* If a character is available to be read, then read it and stuff it into IBUFFER. Otherwise, just return. */ void rl_gather_tyi () { #if defined (__GO32__) char input; if (isatty (0)) { int i = rl_getc (); if (i != EOF) rl_stuff_char (i); } else if (kbhit () && ibuffer_space ()) rl_stuff_char (getkey ()); #else /* !__GO32__ */ int tty = fileno (in_stream); register int tem, result = -1; int chars_avail; char input; #if defined (FIONREAD) result = ioctl (tty, FIONREAD, &chars_avail); #endif #if defined (O_NDELAY) if (result == -1) { int flags; flags = fcntl (tty, F_GETFL, 0); fcntl (tty, F_SETFL, (flags | O_NDELAY)); chars_avail = read (tty, &input, 1); fcntl (tty, F_SETFL, flags); if (chars_avail == -1 && errno == EAGAIN) return; } #endif /* O_NDELAY */ /* If there's nothing available, don't waste time trying to read something. */ if (chars_avail == 0) return; tem = ibuffer_space (); if (chars_avail > tem) chars_avail = tem; /* One cannot read all of the available input. I can only read a single character at a time, or else programs which require input can be thwarted. If the buffer is larger than one character, I lose. Damn! */ if (tem < ibuffer_len) chars_avail = 0; if (result != -1) { while (chars_avail--) rl_stuff_char (rl_getc (in_stream)); } else { if (chars_avail) rl_stuff_char (input); } #endif /* !__GO32__ */ } static int next_macro_key (); /* Read a key, including pending input. */ int rl_read_key () { int c; rl_key_sequence_length++; if (rl_pending_input) { c = rl_pending_input; rl_pending_input = 0; } else { /* If input is coming from a macro, then use that. */ if (c = next_macro_key ()) return (c); /* If the user has an event function, then call it periodically. */ if (rl_event_hook) { while (rl_event_hook && !rl_get_char (&c)) { (*rl_event_hook) (); rl_gather_tyi (); } } else { if (!rl_get_char (&c)) c = rl_getc (in_stream); } } return (c); } /* Found later in this file. */ static void add_macro_char (), with_macro_input (); /* Do the command associated with KEY in MAP. If the associated command is really a keymap, then read another key, and dispatch into that map. */ int _rl_dispatch (key, map) register int key; Keymap map; { int r = 0; if (defining_kbd_macro) add_macro_char (key); if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii) { if (map[ESC].type == ISKMAP) { map = FUNCTION_TO_KEYMAP (map, ESC); key = UNMETA (key); rl_key_sequence_length += 2; return (_rl_dispatch (key, map)); } else ding (); return 0; } switch (map[key].type) { case ISFUNC: { Function *func = map[key].function; if (func != (Function *)NULL) { /* Special case rl_do_lowercase_version (). */ if (func == rl_do_lowercase_version) return (_rl_dispatch (to_lower (key), map)); r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key); /* If we have input pending, then the last command was a prefix command. Don't change the state of rl_last_func. Otherwise, remember the last command executed in this variable. */ if (!rl_pending_input) rl_last_func = map[key].function; } else { rl_abort (); return -1; } } break; case ISKMAP: if (map[key].function != (Function *)NULL) { int newkey; rl_key_sequence_length++; newkey = rl_read_key (); r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key)); } else { rl_abort (); return -1; } break; case ISMACR: if (map[key].function != (Function *)NULL) { char *macro; macro = savestring ((char *)map[key].function); with_macro_input (macro); return 0; } break; } #if defined (VI_MODE) if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap && rl_vi_textmod_command (key)) _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign); #endif return (r); } /* **************************************************************** */ /* */ /* Hacking Keyboard Macros */ /* */ /* **************************************************************** */ /* The currently executing macro string. If this is non-zero, then it is a malloc ()'ed string where input is coming from. */ static char *executing_macro = (char *)NULL; /* The offset in the above string to the next character to be read. */ static int executing_macro_index = 0; /* The current macro string being built. Characters get stuffed in here by add_macro_char (). */ static char *current_macro = (char *)NULL; /* The size of the buffer allocated to current_macro. */ static int current_macro_size = 0; /* The index at which characters are being added to current_macro. */ static int current_macro_index = 0; /* A structure used to save nested macro strings. It is a linked list of string/index for each saved macro. */ struct saved_macro { struct saved_macro *next; char *string; int sindex; }; /* The list of saved macros. */ struct saved_macro *macro_list = (struct saved_macro *)NULL; /* Forward declarations of static functions. Thank you C. */ static void push_executing_macro (), pop_executing_macro (); /* This one has to be declared earlier in the file. */ /* static void add_macro_char (); */ /* Set up to read subsequent input from STRING. STRING is free ()'ed when we are done with it. */ static void with_macro_input (string) char *string; { push_executing_macro (); executing_macro = string; executing_macro_index = 0; } /* Return the next character available from a macro, or 0 if there are no macro characters. */ static int next_macro_key () { if (!executing_macro) return (0); if (!executing_macro[executing_macro_index]) { pop_executing_macro (); return (next_macro_key ()); } return (executing_macro[executing_macro_index++]); } /* Save the currently executing macro on a stack of saved macros. */ static void push_executing_macro () { struct saved_macro *saver; saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro)); saver->next = macro_list; saver->sindex = executing_macro_index; saver->string = executing_macro; macro_list = saver; } /* Discard the current macro, replacing it with the one on the top of the stack of saved macros. */ static void pop_executing_macro () { if (executing_macro) free (executing_macro); executing_macro = (char *)NULL; executing_macro_index = 0; if (macro_list) { struct saved_macro *disposer = macro_list; executing_macro = macro_list->string; executing_macro_index = macro_list->sindex; macro_list = macro_list->next; free (disposer); } } /* Add a character to the macro being built. */ static void add_macro_char (c) int c; { if (current_macro_index + 1 >= current_macro_size) { if (!current_macro) current_macro = xmalloc (current_macro_size = 25); else current_macro = xrealloc (current_macro, current_macro_size += 25); } current_macro[current_macro_index++] = c; current_macro[current_macro_index] = '\0'; } /* Begin defining a keyboard macro. Keystrokes are recorded as they are executed. End the definition with rl_end_kbd_macro (). If a numeric argument was explicitly typed, then append this definition to the end of the existing macro, and start by re-executing the existing macro. */ rl_start_kbd_macro (ignore1, ignore2) int ignore1, ignore2; { if (defining_kbd_macro) { rl_abort (); return -1; } if (rl_explicit_arg) { if (current_macro) with_macro_input (savestring (current_macro)); } else current_macro_index = 0; defining_kbd_macro = 1; return 0; } /* Stop defining a keyboard macro. A numeric argument says to execute the macro right now, that many times, counting the definition as the first time. */ rl_end_kbd_macro (count, ignore) int count, ignore; { if (!defining_kbd_macro) { rl_abort (); return -1; } current_macro_index -= (rl_key_sequence_length - 1); current_macro[current_macro_index] = '\0'; defining_kbd_macro = 0; return (rl_call_last_kbd_macro (--count, 0)); } /* Execute the most recently defined keyboard macro. COUNT says how many times to execute it. */ rl_call_last_kbd_macro (count, ignore) int count, ignore; { if (!current_macro) rl_abort (); if (defining_kbd_macro) { ding (); /* no recursive macros */ current_macro[--current_macro_index] = '\0'; /* erase this char */ return 0; } while (count--) with_macro_input (savestring (current_macro)); return 0; } void _rl_kill_kbd_macro () { if (current_macro) { free (current_macro); current_macro = (char *) NULL; } current_macro_size = current_macro_index = 0; if (executing_macro) { free (executing_macro); executing_macro = (char *) NULL; } executing_macro_index = 0; defining_kbd_macro = 0; } /* **************************************************************** */ /* */ /* Initializations */ /* */ /* **************************************************************** */ /* Initliaze readline (and terminal if not already). */ rl_initialize () { char *t; /* If we have never been called before, initialize the terminal and data structures. */ if (!rl_initialized) { readline_initialize_everything (); rl_initialized++; } /* Initalize the current line information. */ rl_point = rl_end = 0; the_line = rl_line_buffer; the_line[0] = 0; /* We aren't done yet. We haven't even gotten started yet! */ rl_done = 0; /* Check for LC_CTYPE and use its value to decide the defaults for 8-bit character input and output. */ t = getenv ("LC_CTYPE"); if (t && (strcmp (t, "iso-8859-1") == 0 || strcmp (t, "iso_8859_1") == 0)) { _rl_meta_flag = 1; _rl_convert_meta_chars_to_ascii = 0; _rl_output_meta_chars = 1; } /* Tell the history routines what is going on. */ start_using_history (); /* Make the display buffer match the state of the line. */ rl_reset_line_state (); /* No such function typed yet. */ rl_last_func = (Function *)NULL; /* Parsing of key-bindings begins in an enabled state. */ _rl_parsing_conditionalized_out = 0; return 0; } /* Initialize the entire state of the world. */ static void readline_initialize_everything () { /* Find out if we are running in Emacs. */ running_in_emacs = getenv ("EMACS") != (char *)0; /* Set up input and output if they are not already set up. */ if (!rl_instream) rl_instream = stdin; if (!rl_outstream) rl_outstream = stdout; /* Bind in_stream and out_stream immediately. These values may change, but they may also be used before readline_internal () is called. */ in_stream = rl_instream; out_stream = rl_outstream; /* Allocate data structures. */ if (!rl_line_buffer) rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE); /* Initialize the terminal interface. */ init_terminal_io ((char *)NULL); #if !defined (__GO32__) /* Bind tty characters to readline functions. */ readline_default_bindings (); #endif /* !__GO32__ */ /* Initialize the function names. */ rl_initialize_funmap (); /* Read in the init file. */ rl_read_init_file ((char *)NULL); /* XXX */ if (_rl_horizontal_scroll_mode && term_xn) { screenwidth--; screenchars -= screenheight; } /* Override the effect of any `set keymap' assignments in the inputrc file. */ rl_set_keymap_from_edit_mode (); /* Try to bind a common arrow key prefix, if not already bound. */ bind_arrow_keys (); /* If the completion parser's default word break characters haven't been set yet, then do so now. */ if (rl_completer_word_break_characters == (char *)NULL) rl_completer_word_break_characters = rl_basic_word_break_characters; } /* If this system allows us to look at the values of the regular input editing characters, then bind them to their readline equivalents, iff the characters are not bound to keymaps. */ static void readline_default_bindings () { rltty_set_default_bindings (_rl_keymap); } static void bind_arrow_keys_internal () { Function *f; f = rl_function_of_keyseq ("\033[A", _rl_keymap, (int *)NULL); if (!f || f == rl_do_lowercase_version) { _rl_bind_if_unbound ("\033[A", rl_get_previous_history); _rl_bind_if_unbound ("\033[B", rl_get_next_history); _rl_bind_if_unbound ("\033[C", rl_forward); _rl_bind_if_unbound ("\033[D", rl_backward); } f = rl_function_of_keyseq ("\033OA", _rl_keymap, (int *)NULL); if (!f || f == rl_do_lowercase_version) { _rl_bind_if_unbound ("\033OA", rl_get_previous_history); _rl_bind_if_unbound ("\033OB", rl_get_next_history); _rl_bind_if_unbound ("\033OC", rl_forward); _rl_bind_if_unbound ("\033OD", rl_backward); } } /* Try and bind the common arrow key prefix after giving termcap and the inputrc file a chance to bind them and create `real' keymaps for the arrow key prefix. */ static void bind_arrow_keys () { Keymap xkeymap; xkeymap = _rl_keymap; _rl_keymap = emacs_standard_keymap; bind_arrow_keys_internal (); #if defined (VI_MODE) _rl_keymap = vi_movement_keymap; bind_arrow_keys_internal (); #endif _rl_keymap = xkeymap; } /* **************************************************************** */ /* */ /* Numeric Arguments */ /* */ /* **************************************************************** */ /* Handle C-u style numeric args, as well as M--, and M-digits. */ static int rl_digit_loop () { int key, c; while (1) { rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); key = c = rl_read_key (); if (_rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument) { rl_numeric_arg *= 4; continue; } c = UNMETA (c); if (digit_p (c)) { if (rl_explicit_arg) rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0'); else rl_numeric_arg = (c - '0'); rl_explicit_arg = 1; } else { if (c == '-' && !rl_explicit_arg) { rl_numeric_arg = 1; rl_arg_sign = -1; } else { rl_clear_message (); return (_rl_dispatch (key, _rl_keymap)); } } } return 0; } /* Add the current digit to the argument in progress. */ rl_digit_argument (ignore, key) int ignore, key; { rl_pending_input = key; return (rl_digit_loop ()); } /* What to do when you abort reading an argument. */ rl_discard_argument () { ding (); rl_clear_message (); rl_init_argument (); return 0; } /* Create a default argument. */ rl_init_argument () { rl_numeric_arg = rl_arg_sign = 1; rl_explicit_arg = 0; return 0; } /* C-u, universal argument. Multiply the current argument by 4. Read a key. If the key has nothing to do with arguments, then dispatch on it. If the key is the abort character then abort. */ rl_universal_argument () { rl_numeric_arg *= 4; return (rl_digit_loop ()); } /* **************************************************************** */ /* */ /* Terminal and Termcap */ /* */ /* **************************************************************** */ static char *term_buffer = (char *)NULL; static char *term_string_buffer = (char *)NULL; static int tcap_initialized = 0; /* Non-zero means this terminal can't really do anything. */ int dumb_term = 0; /* On Solaris2, sys/types.h #includes sys/reg.h, which #defines PC. Unfortunately, PC is a global variable used by the termcap library. */ #undef PC #if !defined (__linux__) /* If this causes problems, remove the `extern'. */ /* sgi systems seem to want this, AIX doesn't. */ #if defined(sgi) extern #endif char PC, *BC, *UP; #endif /* __linux__ */ /* Some strings to control terminal actions. These are output by tputs (). */ char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace; char *term_pc; /* Non-zero if we determine that the terminal can do character insertion. */ int terminal_can_insert = 0; /* How to insert characters. */ char *term_im, *term_ei, *term_ic, *term_ip, *term_IC; /* How to delete characters. */ char *term_dc, *term_DC; #if defined (HACK_TERMCAP_MOTION) char *term_forward_char; #endif /* HACK_TERMCAP_MOTION */ /* How to go up a line. */ char *term_up; /* A visible bell, if the terminal can be made to flash the screen. */ char *visible_bell; /* Non-zero means that this terminal has a meta key. */ int term_has_meta; /* The string to write to turn on the meta key, if this term has one. */ char *term_mm; /* The string to write to turn off the meta key, if this term has one. */ char *term_mo; /* The key sequences output by the arrow keys, if this terminal has any. */ char *term_ku, *term_kd, *term_kr, *term_kl; /* How to initialize and reset the arrow keys, if this terminal has any. */ char *term_ks, *term_ke; /* Re-initialize the terminal considering that the TERM/TERMCAP variable has changed. */ rl_reset_terminal (terminal_name) char *terminal_name; { init_terminal_io (terminal_name); return 0; } /* Set readline's idea of the screen size. TTY is a file descriptor open to the terminal. If IGNORE_ENV is true, we do not pay attention to the values of $LINES and $COLUMNS. The tests for TERM_STRING_BUFFER being non-null serve to check whether or not we have initialized termcap. */ void _rl_set_screen_size (tty, ignore_env) int tty, ignore_env; { #if defined (TIOCGWINSZ) struct winsize window_size; #endif /* TIOCGWINSZ */ #if defined (TIOCGWINSZ) if (ioctl (tty, TIOCGWINSZ, &window_size) == 0) { screenwidth = (int) window_size.ws_col; screenheight = (int) window_size.ws_row; } #endif /* TIOCGWINSZ */ /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV is unset. */ if (screenwidth <= 0) { char *sw; if (!ignore_env && (sw = getenv ("COLUMNS"))) screenwidth = atoi (sw); if (screenwidth <= 0 && term_string_buffer) screenwidth = tgetnum ("co"); } /* Environment variable LINES overrides setting of "li" if IGNORE_ENV is unset. */ if (screenheight <= 0) { char *sh; if (!ignore_env && (sh = getenv ("LINES"))) screenheight = atoi (sh); if (screenheight <= 0 && term_string_buffer) screenheight = tgetnum ("li"); } /* If all else fails, default to 80x24 terminal. */ if (screenwidth <= 1) screenwidth = 80; if (screenheight <= 0) screenheight = 24; #if defined (SHELL) /* If we're being compiled as part of bash, set the environment variables $LINES and $COLUMNS to new values. */ set_lines_and_columns (screenheight, screenwidth); #endif if (!term_xn) screenwidth--; screenchars = screenwidth * screenheight; } struct _tc_string { char *tc_var; char **tc_value; }; /* This should be kept sorted, just in case we decide to change the search algorithm to something smarter. */ static struct _tc_string tc_strings[] = { "DC", &term_DC, "IC", &term_IC, "ce", &term_clreol, "cl", &term_clrpag, "cr", &term_cr, "dc", &term_dc, "ei", &term_ei, "ic", &term_ic, "im", &term_im, "kd", &term_kd, "kl", &term_kl, "kr", &term_kr, "ku", &term_ku, "ks", &term_ks, "ke", &term_ke, "le", &term_backspace, "mm", &term_mm, "mo", &term_mo, #if defined (HACK_TERMCAP_MOTION) "nd", &term_forward_char, #endif "pc", &term_pc, "up", &term_up, "vb", &visible_bell, }; #define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string)) /* Read the desired terminal capability strings into BP. The capabilities are described in the TC_STRINGS table. */ static void get_term_capabilities (bp) char **bp; { register int i; for (i = 0; i < NUM_TC_STRINGS; i++) *(tc_strings[i].tc_value) = tgetstr (tc_strings[i].tc_var, bp); tcap_initialized = 1; } static int init_terminal_io (terminal_name) char *terminal_name; { #if defined (__GO32__) screenwidth = ScreenCols (); screenheight = ScreenRows (); screenchars = screenwidth * screenheight; term_cr = "\r"; term_im = term_ei = term_ic = term_IC = (char *)NULL; term_up = term_dc = term_DC = visible_bell = (char *)NULL; /* Does the __GO32__ have a meta key? I don't know. */ term_has_meta = 0; term_mm = term_mo = (char *)NULL; /* It probably has arrow keys, but I don't know what they are. */ term_ku = term_kd = term_kr = term_kl = (char *)NULL; #if defined (HACK_TERMCAP_MOTION) term_forward_char = (char *)NULL; #endif /* HACK_TERMCAP_MOTION */ terminal_can_insert = term_xn = 0; return; #else /* !__GO32__ */ char *term, *buffer; int tty; Keymap xkeymap; term = terminal_name ? terminal_name : getenv ("TERM"); if (!term_string_buffer) term_string_buffer = xmalloc (2048); if (!term_buffer) term_buffer = xmalloc (2048); buffer = term_string_buffer; term_clrpag = term_cr = term_clreol = (char *)NULL; if (!term) term = "dumb"; if (tgetent (term_buffer, term) <= 0) { dumb_term = 1; screenwidth = 79; screenheight = 24; screenchars = 79 * 24; term_cr = "\r"; term_im = term_ei = term_ic = term_IC = (char *)NULL; term_up = term_dc = term_DC = visible_bell = (char *)NULL; term_ku = term_kd = term_kl = term_kr = (char *)NULL; #if defined (HACK_TERMCAP_MOTION) term_forward_char = (char *)NULL; #endif terminal_can_insert = 0; return 0; } get_term_capabilities (&buffer); /* Set up the variables that the termcap library expects the application to provide. */ PC = term_pc ? *term_pc : 0; BC = term_backspace; UP = term_up; if (!term_cr) term_cr = "\r"; if (rl_instream) tty = fileno (rl_instream); else tty = 0; screenwidth = screenheight = 0; term_xn = tgetflag ("am") && tgetflag ("xn"); _rl_set_screen_size (tty, 0); /* "An application program can assume that the terminal can do character insertion if *any one of* the capabilities `IC', `im', `ic' or `ip' is provided." But we can't do anything if only `ip' is provided, so... */ terminal_can_insert = (term_IC || term_im || term_ic); /* Check to see if this terminal has a meta key and clear the capability variables if there is none. */ term_has_meta = (tgetflag ("km") || tgetflag ("MT")); if (!term_has_meta) { term_mm = (char *)NULL; term_mo = (char *)NULL; } /* Attempt to find and bind the arrow keys. Do not override already bound keys in an overzealous attempt, however. */ xkeymap = _rl_keymap; _rl_keymap = emacs_standard_keymap; _rl_bind_if_unbound (term_ku, rl_get_previous_history); _rl_bind_if_unbound (term_kd, rl_get_next_history); _rl_bind_if_unbound (term_kr, rl_forward); _rl_bind_if_unbound (term_kl, rl_backward); #if defined (VI_MODE) _rl_keymap = vi_movement_keymap; _rl_bind_if_unbound (term_ku, rl_get_previous_history); _rl_bind_if_unbound (term_kd, rl_get_next_history); _rl_bind_if_unbound (term_kr, rl_forward); _rl_bind_if_unbound (term_kl, rl_backward); #endif /* VI_MODE */ _rl_keymap = xkeymap; #endif /* !__GO32__ */ return 0; } char * rl_get_termcap (cap) char *cap; { register int i; if (tcap_initialized == 0) return ((char *)NULL); for (i = 0; i < NUM_TC_STRINGS; i++) { if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0) return *(tc_strings[i].tc_value); } return ((char *)NULL); } /* A function for the use of tputs () */ int _rl_output_character_function (c) int c; { return putc (c, out_stream); } /* Write COUNT characters from STRING to the output stream. */ void _rl_output_some_chars (string, count) char *string; int count; { fwrite (string, 1, count, out_stream); } /* Move the cursor back. */ backspace (count) int count; { register int i; #if !defined (__GO32__) if (term_backspace) for (i = 0; i < count; i++) tputs (term_backspace, 1, _rl_output_character_function); else #endif /* !__GO32__ */ for (i = 0; i < count; i++) putc ('\b', out_stream); return 0; } /* Move to the start of the next line. */ crlf () { #if defined (NEW_TTY_DRIVER) tputs (term_cr, 1, _rl_output_character_function); #endif /* NEW_TTY_DRIVER */ putc ('\n', out_stream); return 0; } rl_tty_status (count, key) int count, key; { #if defined (TIOCSTAT) ioctl (1, TIOCSTAT, (char *)0); rl_refresh_line (); #else ding (); #endif return 0; } /* **************************************************************** */ /* */ /* Utility Functions */ /* */ /* **************************************************************** */ /* Return 0 if C is not a member of the class of characters that belong in words, or 1 if it is. */ int allow_pathname_alphabetic_chars = 0; char *pathname_alphabetic_chars = "/-_=~.#$"; int alphabetic (c) int c; { if (pure_alphabetic (c) || (digit_p (c))) return (1); if (allow_pathname_alphabetic_chars) return (strchr (pathname_alphabetic_chars, c) != NULL); else return (0); } /* Ring the terminal bell. */ int ding () { if (readline_echoing_p) { #if !defined (__GO32__) switch (_rl_bell_preference) { case NO_BELL: default: break; case VISIBLE_BELL: if (visible_bell) { tputs (visible_bell, 1, _rl_output_character_function); break; } /* FALLTHROUGH */ case AUDIBLE_BELL: fprintf (stderr, "\007"); fflush (stderr); break; } #else /* __GO32__ */ fprintf (stderr, "\007"); fflush (stderr); #endif /* __GO32__ */ return (0); } return (-1); } /* How to abort things. */ rl_abort (count, key) int count, key; { ding (); rl_clear_message (); rl_init_argument (); rl_pending_input = 0; defining_kbd_macro = 0; while (executing_macro) pop_executing_macro (); rl_last_func = (Function *)NULL; longjmp (readline_top_level, 1); } /* Return a copy of the string between FROM and TO. FROM is inclusive, TO is not. */ char * rl_copy_text (from, to) int from, to; { register int length; char *copy; /* Fix it if the caller is confused. */ if (from > to) { int t = from; from = to; to = t; } length = to - from; copy = xmalloc (1 + length); strncpy (copy, the_line + from, length); copy[length] = '\0'; return (copy); } /* Increase the size of RL_LINE_BUFFER until it has enough space to hold LEN characters. */ void rl_extend_line_buffer (len) int len; { while (len >= rl_line_buffer_len) { rl_line_buffer_len += DEFAULT_BUFFER_SIZE; rl_line_buffer = xrealloc (rl_line_buffer, rl_line_buffer_len); } the_line = rl_line_buffer; } /* **************************************************************** */ /* */ /* Insert and Delete */ /* */ /* **************************************************************** */ /* Insert a string of text into the line at point. This is the only way that you should do insertion. rl_insert () calls this function. */ rl_insert_text (string) char *string; { register int i, l = strlen (string); if (rl_end + l >= rl_line_buffer_len) rl_extend_line_buffer (rl_end + l); for (i = rl_end; i >= rl_point; i--) the_line[i + l] = the_line[i]; strncpy (the_line + rl_point, string, l); /* Remember how to undo this if we aren't undoing something. */ if (!doing_an_undo) { /* If possible and desirable, concatenate the undos. */ if ((l == 1) && rl_undo_list && (rl_undo_list->what == UNDO_INSERT) && (rl_undo_list->end == rl_point) && (rl_undo_list->end - rl_undo_list->start < 20)) rl_undo_list->end++; else rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL); } rl_point += l; rl_end += l; the_line[rl_end] = '\0'; return l; } /* Delete the string between FROM and TO. FROM is inclusive, TO is not. */ rl_delete_text (from, to) int from, to; { register char *text; register int diff, i; /* Fix it if the caller is confused. */ if (from > to) { int t = from; from = to; to = t; } text = rl_copy_text (from, to); /* Some versions of strncpy() can't handle overlapping arguments. */ diff = to - from; for (i = from; i < rl_end - diff; i++) the_line[i] = the_line[i + diff]; /* Remember how to undo this delete. */ if (!doing_an_undo) rl_add_undo (UNDO_DELETE, from, to, text); else free (text); rl_end -= diff; the_line[rl_end] = '\0'; return (diff); } /* **************************************************************** */ /* */ /* Readline character functions */ /* */ /* **************************************************************** */ /* This is not a gap editor, just a stupid line input routine. No hair is involved in writing any of the functions, and none should be. */ /* Note that: rl_end is the place in the string that we would place '\0'; i.e., it is always safe to place '\0' there. rl_point is the place in the string where the cursor is. Sometimes this is the same as rl_end. Any command that is called interactively receives two arguments. The first is a count: the numeric arg pased to this command. The second is the key which invoked this command. */ /* **************************************************************** */ /* */ /* Movement Commands */ /* */ /* **************************************************************** */ /* Note that if you `optimize' the display for these functions, you cannot use said functions in other functions which do not do optimizing display. I.e., you will have to update the data base for rl_redisplay, and you might as well let rl_redisplay do that job. */ /* Move forward COUNT characters. */ rl_forward (count, key) int count, key; { if (count < 0) rl_backward (-count); else if (count > 0) { int end = rl_point + count; #if defined (VI_MODE) int lend = rl_end - (rl_editing_mode == vi_mode); #else int lend = rl_end; #endif if (end > lend) { rl_point = lend; ding (); } else rl_point = end; } return 0; } /* Move backward COUNT characters. */ rl_backward (count, key) int count, key; { if (count < 0) rl_forward (-count); else if (count > 0) { if (rl_point < count) { rl_point = 0; ding (); } else rl_point -= count; } return 0; } /* Move to the beginning of the line. */ rl_beg_of_line (count, key) int count, key; { rl_point = 0; return 0; } /* Move to the end of the line. */ rl_end_of_line (count, key) int count, key; { rl_point = rl_end; return 0; } /* Move forward a word. We do what Emacs does. */ rl_forward_word (count, key) int count, key; { int c; if (count < 0) { rl_backward_word (-count); return 0; } while (count) { if (rl_point == rl_end) return 0; /* If we are not in a word, move forward until we are in one. Then, move forward until we hit a non-alphabetic character. */ c = the_line[rl_point]; if (!alphabetic (c)) { while (++rl_point < rl_end) { c = the_line[rl_point]; if (alphabetic (c)) break; } } if (rl_point == rl_end) return 0; while (++rl_point < rl_end) { c = the_line[rl_point]; if (!alphabetic (c)) break; } --count; } return 0; } /* Move backward a word. We do what Emacs does. */ rl_backward_word (count, key) int count, key; { int c; if (count < 0) { rl_forward_word (-count); return 0; } while (count) { if (!rl_point) return 0; /* Like rl_forward_word (), except that we look at the characters just before point. */ c = the_line[rl_point - 1]; if (!alphabetic (c)) { while (--rl_point) { c = the_line[rl_point - 1]; if (alphabetic (c)) break; } } while (rl_point) { c = the_line[rl_point - 1]; if (!alphabetic (c)) break; else --rl_point; } --count; } return 0; } /* Clear the current line. Numeric argument to C-l does this. */ rl_refresh_line () { int curr_line, nleft; /* Find out whether or not there might be invisible characters in the editing buffer. */ if (rl_display_prompt == rl_prompt) nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length; else nleft = _rl_last_c_pos - screenwidth; if (nleft > 0) curr_line = 1 + nleft / screenwidth; else curr_line = 0; _rl_move_vert (curr_line); _rl_move_cursor_relative (0, the_line); /* XXX is this right */ #if defined (__GO32__) { int row, col, width, row_start; ScreenGetCursor (&row, &col); width = ScreenCols (); row_start = ScreenPrimary + (row * width); memset (row_start + col, 0, (width - col) * 2); } #else /* !__GO32__ */ if (term_clreol) tputs (term_clreol, 1, _rl_output_character_function); #endif /* !__GO32__ */ rl_forced_update_display (); rl_display_fixed = 1; return 0; } /* C-l typed to a line without quoting clears the screen, and then reprints the prompt and the current input line. Given a numeric arg, redraw only the current line. */ rl_clear_screen (count, key) int count, key; { if (rl_explicit_arg) { rl_refresh_line (); return 0; } #if !defined (__GO32__) if (term_clrpag) tputs (term_clrpag, 1, _rl_output_character_function); else #endif /* !__GO32__ */ crlf (); rl_forced_update_display (); rl_display_fixed = 1; return 0; } rl_arrow_keys (count, c) int count, c; { int ch; ch = rl_read_key (); switch (to_upper (ch)) { case 'A': rl_get_previous_history (count); break; case 'B': rl_get_next_history (count); break; case 'C': rl_forward (count); break; case 'D': rl_backward (count); break; default: ding (); } return 0; } /* **************************************************************** */ /* */ /* Text commands */ /* */ /* **************************************************************** */ /* Insert the character C at the current location, moving point forward. */ rl_insert (count, c) int count, c; { register int i; char *string; if (count <= 0) return 0; /* If we can optimize, then do it. But don't let people crash readline because of extra large arguments. */ if (count > 1 && count < 1024) { string = xmalloc (1 + count); for (i = 0; i < count; i++) string[i] = c; string[i] = '\0'; rl_insert_text (string); free (string); return 0; } if (count > 1024) { int decreaser; char str[1024+1]; for (i = 0; i < 1024; i++) str[i] = c; while (count) { decreaser = (count > 1024 ? 1024 : count); str[decreaser] = '\0'; rl_insert_text (str); count -= decreaser; } return 0; } /* We are inserting a single character. If there is pending input, then make a string of all of the pending characters that are bound to rl_insert, and insert them all. */ if (any_typein) { int key = 0, t; i = 0; string = xmalloc (ibuffer_len + 1); string[i++] = c; while ((t = rl_get_char (&key)) && (_rl_keymap[key].type == ISFUNC && _rl_keymap[key].function == rl_insert)) string[i++] = key; if (t) rl_unget_char (key); string[i] = '\0'; rl_insert_text (string); free (string); } else { /* Inserting a single character. */ char str[2]; str[1] = '\0'; str[0] = c; rl_insert_text (str); } return 0; } /* Insert the next typed character verbatim. */ rl_quoted_insert (count, key) int count, key; { int c; c = rl_read_key (); return (rl_insert (count, c)); } /* Insert a tab character. */ rl_tab_insert (count, key) int count, key; { return (rl_insert (count, '\t')); } /* What to do when a NEWLINE is pressed. We accept the whole line. KEY is the key that invoked this command. I guess it could have meaning in the future. */ rl_newline (count, key) int count, key; { rl_done = 1; #if defined (VI_MODE) _rl_vi_done_inserting (); _rl_vi_reset_last (); #endif /* VI_MODE */ if (readline_echoing_p) _rl_update_final (); return 0; } rl_clean_up_for_exit () { if (readline_echoing_p) { _rl_move_vert (_rl_vis_botlin); _rl_vis_botlin = 0; fflush (out_stream); rl_restart_output (); } return 0; } /* What to do for some uppercase characters, like meta characters, and some characters appearing in emacs_ctlx_keymap. This function is just a stub, you bind keys to it and the code in _rl_dispatch () is special cased. */ rl_do_lowercase_version (ignore1, ignore2) int ignore1, ignore2; { return 0; } /* Rubout the character behind point. */ rl_rubout (count, key) int count, key; { if (count < 0) { rl_delete (-count); return 0; } if (!rl_point) { ding (); return -1; } if (count > 1 || rl_explicit_arg) { int orig_point = rl_point; rl_backward (count); rl_kill_text (orig_point, rl_point); } else { int c = the_line[--rl_point]; rl_delete_text (rl_point, rl_point + 1); if (rl_point == rl_end && isprint (c) && _rl_last_c_pos) { int l; l = rl_character_len (c, rl_point); _rl_erase_at_end_of_line (l); } } return 0; } /* Delete the character under the cursor. Given a numeric argument, kill that many characters instead. */ rl_delete (count, invoking_key) int count, invoking_key; { if (count < 0) { return (rl_rubout (-count)); } if (rl_point == rl_end) { ding (); return -1; } if (count > 1 || rl_explicit_arg) { int orig_point = rl_point; rl_forward (count); rl_kill_text (orig_point, rl_point); rl_point = orig_point; return 0; } else return (rl_delete_text (rl_point, rl_point + 1)); } /* Delete all spaces and tabs around point. */ rl_delete_horizontal_space (count, ignore) int count, ignore; { int start = rl_point; while (rl_point && whitespace (the_line[rl_point - 1])) rl_point--; start = rl_point; while (rl_point < rl_end && whitespace (the_line[rl_point])) rl_point++; if (start != rl_point) { rl_delete_text (start, rl_point); rl_point = start; } return 0; } /* **************************************************************** */ /* */ /* Kill commands */ /* */ /* **************************************************************** */ /* The next two functions mimic unix line editing behaviour, except they save the deleted text on the kill ring. This is safer than not saving it, and since we have a ring, nobody should get screwed. */ /* This does what C-w does in Unix. We can't prevent people from using behaviour that they expect. */ rl_unix_word_rubout (count, key) int count, key; { if (!rl_point) ding (); else { int orig_point = rl_point; while (rl_point && whitespace (the_line[rl_point - 1])) rl_point--; while (rl_point && !whitespace (the_line[rl_point - 1])) rl_point--; rl_kill_text (orig_point, rl_point); } return 0; } /* Here is C-u doing what Unix does. You don't *have* to use these key-bindings. We have a choice of killing the entire line, or killing from where we are to the start of the line. We choose the latter, because if you are a Unix weenie, then you haven't backspaced into the line at all, and if you aren't, then you know what you are doing. */ rl_unix_line_discard (count, key) int count, key; { if (!rl_point) ding (); else { rl_kill_text (rl_point, 0); rl_point = 0; } return 0; } /* **************************************************************** */ /* */ /* Commands For Typos */ /* */ /* **************************************************************** */ /* Random and interesting things in here. */ /* **************************************************************** */ /* */ /* Changing Case */ /* */ /* **************************************************************** */ /* The three kinds of things that we know how to do. */ #define UpCase 1 #define DownCase 2 #define CapCase 3 static int rl_change_case (); /* Uppercase the word at point. */ rl_upcase_word (count, key) int count, key; { return (rl_change_case (count, UpCase)); } /* Lowercase the word at point. */ rl_downcase_word (count, key) int count, key; { return (rl_change_case (count, DownCase)); } /* Upcase the first letter, downcase the rest. */ rl_capitalize_word (count, key) int count, key; { return (rl_change_case (count, CapCase)); } /* The meaty function. Change the case of COUNT words, performing OP on them. OP is one of UpCase, DownCase, or CapCase. If a negative argument is given, leave point where it started, otherwise, leave it where it moves to. */ static int rl_change_case (count, op) int count, op; { register int start = rl_point, end; int state = 0; rl_forward_word (count); end = rl_point; if (count < 0) { int temp = start; start = end; end = temp; } /* We are going to modify some text, so let's prepare to undo it. */ rl_modifying (start, end); for (; start < end; start++) { switch (op) { case UpCase: the_line[start] = to_upper (the_line[start]); break; case DownCase: the_line[start] = to_lower (the_line[start]); break; case CapCase: if (state == 0) { the_line[start] = to_upper (the_line[start]); state = 1; } else { the_line[start] = to_lower (the_line[start]); } if (!pure_alphabetic (the_line[start])) state = 0; break; default: abort (); return -1; } } rl_point = end; return 0; } /* **************************************************************** */ /* */ /* Transposition */ /* */ /* **************************************************************** */ /* Transpose the words at point. */ rl_transpose_words (count, key) int count, key; { char *word1, *word2; int w1_beg, w1_end, w2_beg, w2_end; int orig_point = rl_point; if (!count) return 0; /* Find the two words. */ rl_forward_word (count); w2_end = rl_point; rl_backward_word (1); w2_beg = rl_point; rl_backward_word (count); w1_beg = rl_point; rl_forward_word (1); w1_end = rl_point; /* Do some check to make sure that there really are two words. */ if ((w1_beg == w2_beg) || (w2_beg < w1_end)) { ding (); rl_point = orig_point; return -1; } /* Get the text of the words. */ word1 = rl_copy_text (w1_beg, w1_end); word2 = rl_copy_text (w2_beg, w2_end); /* We are about to do many insertions and deletions. Remember them as one operation. */ rl_begin_undo_group (); /* Do the stuff at word2 first, so that we don't have to worry about word1 moving. */ rl_point = w2_beg; rl_delete_text (w2_beg, w2_end); rl_insert_text (word1); rl_point = w1_beg; rl_delete_text (w1_beg, w1_end); rl_insert_text (word2); /* This is exactly correct since the text before this point has not changed in length. */ rl_point = w2_end; /* I think that does it. */ rl_end_undo_group (); free (word1); free (word2); return 0; } /* Transpose the characters at point. If point is at the end of the line, then transpose the characters before point. */ rl_transpose_chars (count, key) int count, key; { char dummy[2]; if (!count) return 0; if (!rl_point || rl_end < 2) { ding (); return -1; } rl_begin_undo_group (); if (rl_point == rl_end) { --rl_point; count = 1; } rl_point--; dummy[0] = the_line[rl_point]; dummy[1] = '\0'; rl_delete_text (rl_point, rl_point + 1); rl_point += count; if (rl_point > rl_end) rl_point = rl_end; else if (rl_point < 0) rl_point = 0; rl_insert_text (dummy); rl_end_undo_group (); return 0; } /* **************************************************************** */ /* */ /* Undo, and Undoing */ /* */ /* **************************************************************** */ /* The current undo list for THE_LINE. */ UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL; /* Remember how to undo something. Concatenate some undos if that seems right. */ void rl_add_undo (what, start, end, text) enum undo_code what; int start, end; char *text; { UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST)); temp->what = what; temp->start = start; temp->end = end; temp->text = text; temp->next = rl_undo_list; rl_undo_list = temp; } /* Free the existing undo list. */ void free_undo_list () { while (rl_undo_list) { UNDO_LIST *release = rl_undo_list; rl_undo_list = rl_undo_list->next; if (release->what == UNDO_DELETE) free (release->text); free (release); } rl_undo_list = (UNDO_LIST *)NULL; } /* Undo the next thing in the list. Return 0 if there is nothing to undo, or non-zero if there was. */ int rl_do_undo () { UNDO_LIST *release; int waiting_for_begin = 0; undo_thing: if (!rl_undo_list) return (0); doing_an_undo = 1; switch (rl_undo_list->what) { /* Undoing deletes means inserting some text. */ case UNDO_DELETE: rl_point = rl_undo_list->start; rl_insert_text (rl_undo_list->text); free (rl_undo_list->text); break; /* Undoing inserts means deleting some text. */ case UNDO_INSERT: rl_delete_text (rl_undo_list->start, rl_undo_list->end); rl_point = rl_undo_list->start; break; /* Undoing an END means undoing everything 'til we get to a BEGIN. */ case UNDO_END: waiting_for_begin++; break; /* Undoing a BEGIN means that we are done with this group. */ case UNDO_BEGIN: if (waiting_for_begin) waiting_for_begin--; else ding (); break; } doing_an_undo = 0; release = rl_undo_list; rl_undo_list = rl_undo_list->next; free (release); if (waiting_for_begin) goto undo_thing; return (1); } /* Begin a group. Subsequent undos are undone as an atomic operation. */ int rl_begin_undo_group () { rl_add_undo (UNDO_BEGIN, 0, 0, 0); return 0; } /* End an undo group started with rl_begin_undo_group (). */ int rl_end_undo_group () { rl_add_undo (UNDO_END, 0, 0, 0); return 0; } /* Save an undo entry for the text from START to END. */ rl_modifying (start, end) int start, end; { if (start > end) { int t = start; start = end; end = t; } if (start != end) { char *temp = rl_copy_text (start, end); rl_begin_undo_group (); rl_add_undo (UNDO_DELETE, start, end, temp); rl_add_undo (UNDO_INSERT, start, end, (char *)NULL); rl_end_undo_group (); } return 0; } /* Revert the current line to its previous state. */ int rl_revert_line (count, key) int count, key; { if (!rl_undo_list) ding (); else { while (rl_undo_list) rl_do_undo (); } return 0; } /* Do some undoing of things that were done. */ int rl_undo_command (count, key) int count, key; { if (count < 0) return 0; /* Nothing to do. */ while (count) { if (rl_do_undo ()) count--; else { ding (); break; } } return 0; } /* **************************************************************** */ /* */ /* History Utilities */ /* */ /* **************************************************************** */ /* We already have a history library, and that is what we use to control the history features of readline. However, this is our local interface to the history mechanism. */ /* While we are editing the history, this is the saved version of the original line. */ HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL; /* Set the history pointer back to the last entry in the history. */ static void start_using_history () { using_history (); if (saved_line_for_history) _rl_free_history_entry (saved_line_for_history); saved_line_for_history = (HIST_ENTRY *)NULL; } /* Free the contents (and containing structure) of a HIST_ENTRY. */ void _rl_free_history_entry (entry) HIST_ENTRY *entry; { if (!entry) return; if (entry->line) free (entry->line); free (entry); } /* Perhaps put back the current line if it has changed. */ maybe_replace_line () { HIST_ENTRY *temp = current_history (); /* If the current line has changed, save the changes. */ if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list)) { temp = replace_history_entry (where_history (), the_line, rl_undo_list); free (temp->line); free (temp); } return 0; } /* Put back the saved_line_for_history if there is one. */ maybe_unsave_line () { if (saved_line_for_history) { int line_len; line_len = strlen (saved_line_for_history->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, saved_line_for_history->line); rl_undo_list = (UNDO_LIST *)saved_line_for_history->data; _rl_free_history_entry (saved_line_for_history); saved_line_for_history = (HIST_ENTRY *)NULL; rl_end = rl_point = strlen (the_line); } else ding (); return 0; } /* Save the current line in saved_line_for_history. */ maybe_save_line () { if (!saved_line_for_history) { saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); saved_line_for_history->line = savestring (the_line); saved_line_for_history->data = (char *)rl_undo_list; } return 0; } /* **************************************************************** */ /* */ /* History Commands */ /* */ /* **************************************************************** */ /* Meta-< goes to the start of the history. */ rl_beginning_of_history (count, key) int count, key; { return (rl_get_previous_history (1 + where_history ())); } /* Meta-> goes to the end of the history. (The current line). */ rl_end_of_history (count, key) int count, key; { maybe_replace_line (); using_history (); maybe_unsave_line (); return 0; } /* Move down to the next history line. */ rl_get_next_history (count, key) int count, key; { HIST_ENTRY *temp = (HIST_ENTRY *)NULL; if (count < 0) return (rl_get_previous_history (-count)); if (!count) return 0; maybe_replace_line (); while (count) { temp = next_history (); if (!temp) break; --count; } if (!temp) maybe_unsave_line (); else { int line_len; line_len = strlen (temp->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, temp->line); rl_undo_list = (UNDO_LIST *)temp->data; rl_end = rl_point = strlen (the_line); #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_point = 0; #endif /* VI_MODE */ } return 0; } /* Get the previous item out of our interactive history, making it the current line. If there is no previous history, just ding. */ rl_get_previous_history (count, key) int count, key; { HIST_ENTRY *old_temp = (HIST_ENTRY *)NULL; HIST_ENTRY *temp = (HIST_ENTRY *)NULL; if (count < 0) return (rl_get_next_history (-count)); if (!count) return 0; /* If we don't have a line saved, then save this one. */ maybe_save_line (); /* If the current line has changed, save the changes. */ maybe_replace_line (); while (count) { temp = previous_history (); if (!temp) break; else old_temp = temp; --count; } /* If there was a large argument, and we moved back to the start of the history, that is not an error. So use the last value found. */ if (!temp && old_temp) temp = old_temp; if (!temp) ding (); else { int line_len; line_len = strlen (temp->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, temp->line); rl_undo_list = (UNDO_LIST *)temp->data; rl_end = rl_point = line_len; #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_point = 0; #endif /* VI_MODE */ } return 0; } /* Make C be the next command to be executed. */ rl_execute_next (c) int c; { rl_pending_input = c; return 0; } /* **************************************************************** */ /* */ /* The Mark and the Region. */ /* */ /* **************************************************************** */ /* Set the mark at POSITION. */ rl_set_mark (position) int position; { if (position > rl_end) return -1; rl_mark = position; return 0; } /* Exchange the position of mark and point. */ rl_exchange_mark_and_point (count, key) int count, key; { if (rl_mark > rl_end) rl_mark = -1; if (rl_mark == -1) { ding (); return -1; } else { int temp = rl_point; rl_point = rl_mark; rl_mark = temp; } return 0; } /* **************************************************************** */ /* */ /* Killing Mechanism */ /* */ /* **************************************************************** */ /* What we assume for a max number of kills. */ #define DEFAULT_MAX_KILLS 10 /* The real variable to look at to find out when to flush kills. */ int rl_max_kills = DEFAULT_MAX_KILLS; /* Where to store killed text. */ char **rl_kill_ring = (char **)NULL; /* Where we are in the kill ring. */ int rl_kill_index = 0; /* How many slots we have in the kill ring. */ int rl_kill_ring_length = 0; /* How to say that you only want to save a certain amount of kill material. */ rl_set_retained_kills (num) int num; { return 0; } /* The way to kill something. This appends or prepends to the last kill, if the last command was a kill command. if FROM is less than TO, then the text is appended, otherwise prepended. If the last command was not a kill command, then a new slot is made for this kill. */ rl_kill_text (from, to) int from, to; { int slot; char *text; /* Is there anything to kill? */ if (from == to) { last_command_was_kill++; return 0; } text = rl_copy_text (from, to); /* Delete the copied text from the line. */ rl_delete_text (from, to); /* First, find the slot to work with. */ if (!last_command_was_kill) { /* Get a new slot. */ if (!rl_kill_ring) { /* If we don't have any defined, then make one. */ rl_kill_ring = (char **) xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *)); rl_kill_ring[slot = 0] = (char *)NULL; } else { /* We have to add a new slot on the end, unless we have exceeded the max limit for remembering kills. */ slot = rl_kill_ring_length; if (slot == rl_max_kills) { register int i; free (rl_kill_ring[0]); for (i = 0; i < slot; i++) rl_kill_ring[i] = rl_kill_ring[i + 1]; } else { slot = rl_kill_ring_length += 1; rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *)); } rl_kill_ring[--slot] = (char *)NULL; } } else slot = rl_kill_ring_length - 1; /* If the last command was a kill, prepend or append. */ if (last_command_was_kill && rl_editing_mode != vi_mode) { char *old = rl_kill_ring[slot]; char *new = xmalloc (1 + strlen (old) + strlen (text)); if (from < to) { strcpy (new, old); strcat (new, text); } else { strcpy (new, text); strcat (new, old); } free (old); free (text); rl_kill_ring[slot] = new; } else { rl_kill_ring[slot] = text; } rl_kill_index = slot; last_command_was_kill++; return 0; } /* Now REMEMBER! In order to do prepending or appending correctly, kill commands always make rl_point's original position be the FROM argument, and rl_point's extent be the TO argument. */ /* **************************************************************** */ /* */ /* Killing Commands */ /* */ /* **************************************************************** */ /* Delete the word at point, saving the text in the kill ring. */ rl_kill_word (count, key) int count, key; { int orig_point = rl_point; if (count < 0) return (rl_backward_kill_word (-count)); else { rl_forward_word (count); if (rl_point != orig_point) rl_kill_text (orig_point, rl_point); rl_point = orig_point; } return 0; } /* Rubout the word before point, placing it on the kill ring. */ rl_backward_kill_word (count, ignore) int count, ignore; { int orig_point = rl_point; if (count < 0) return (rl_kill_word (-count)); else { rl_backward_word (count); if (rl_point != orig_point) rl_kill_text (orig_point, rl_point); } return 0; } /* Kill from here to the end of the line. If DIRECTION is negative, kill back to the line start instead. */ rl_kill_line (direction, ignore) int direction, ignore; { int orig_point = rl_point; if (direction < 0) return (rl_backward_kill_line (1)); else { rl_end_of_line (); if (orig_point != rl_point) rl_kill_text (orig_point, rl_point); rl_point = orig_point; } return 0; } /* Kill backwards to the start of the line. If DIRECTION is negative, kill forwards to the line end instead. */ rl_backward_kill_line (direction, ignore) int direction, ignore; { int orig_point = rl_point; if (direction < 0) return (rl_kill_line (1)); else { if (!rl_point) ding (); else { rl_beg_of_line (); rl_kill_text (orig_point, rl_point); } } return 0; } /* Kill the whole line, no matter where point is. */ rl_kill_full_line (count, ignore) int count, ignore; { rl_begin_undo_group (); rl_point = 0; rl_kill_text (rl_point, rl_end); rl_end_undo_group (); return 0; } /* Yank back the last killed text. This ignores arguments. */ rl_yank (count, ignore) int count, ignore; { if (!rl_kill_ring) { rl_abort (); return -1; } rl_set_mark (rl_point); rl_insert_text (rl_kill_ring[rl_kill_index]); return 0; } /* If the last command was yank, or yank_pop, and the text just before point is identical to the current kill item, then delete that text from the line, rotate the index down, and yank back some other text. */ rl_yank_pop (count, key) int count, key; { int l; if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) || !rl_kill_ring) { rl_abort (); return -1; } l = strlen (rl_kill_ring[rl_kill_index]); if (((rl_point - l) >= 0) && (strncmp (the_line + (rl_point - l), rl_kill_ring[rl_kill_index], l) == 0)) { rl_delete_text ((rl_point - l), rl_point); rl_point -= l; rl_kill_index--; if (rl_kill_index < 0) rl_kill_index = rl_kill_ring_length - 1; rl_yank (1, 0); return 0; } else { rl_abort (); return -1; } } /* Yank the COUNTth argument from the previous history line. */ rl_yank_nth_arg (count, ignore) int count, ignore; { register HIST_ENTRY *entry = previous_history (); char *arg; if (entry) next_history (); else { ding (); return -1; } arg = history_arg_extract (count, count, entry->line); if (!arg || !*arg) { ding (); return -1; } rl_begin_undo_group (); #if defined (VI_MODE) /* Vi mode always inserts a space before yanking the argument, and it inserts it right *after* rl_point. */ if (rl_editing_mode == vi_mode) { rl_vi_append_mode (); rl_insert_text (" "); } #endif /* VI_MODE */ rl_insert_text (arg); free (arg); rl_end_undo_group (); return 0; } /* Yank the last argument from the previous history line. This `knows' how rl_yank_nth_arg treats a count of `$'. With an argument, this behaves the same as rl_yank_nth_arg. */ int rl_yank_last_arg (count, key) int count, key; { if (rl_explicit_arg) return (rl_yank_nth_arg (count, key)); else return (rl_yank_nth_arg ('$', key)); } /* How to toggle back and forth between editing modes. */ rl_vi_editing_mode (count, key) int count, key; { #if defined (VI_MODE) rl_editing_mode = vi_mode; rl_vi_insertion_mode (); return 0; #endif /* VI_MODE */ } rl_emacs_editing_mode (count, key) int count, key; { rl_editing_mode = emacs_mode; _rl_keymap = emacs_standard_keymap; return 0; } /* **************************************************************** */ /* */ /* USG (System V) Support */ /* */ /* **************************************************************** */ int rl_getc (stream) FILE *stream; { int result; unsigned char c; #if defined (__GO32__) if (isatty (0)) return (getkey () & 0x7F); #endif /* __GO32__ */ while (1) { result = read (fileno (stream), &c, sizeof (unsigned char)); if (result == sizeof (unsigned char)) return (c); /* If zero characters are returned, then the file that we are reading from is empty! Return EOF in that case. */ if (result == 0) return (EOF); #if defined (EWOULDBLOCK) if (errno == EWOULDBLOCK) { int flags; if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0) return (EOF); if (flags & O_NDELAY) { flags &= ~O_NDELAY; fcntl (fileno (stream), F_SETFL, flags); continue; } continue; } #endif /* EWOULDBLOCK */ #if defined (_POSIX_VERSION) && defined (EAGAIN) && defined (O_NONBLOCK) if (errno == EAGAIN) { int flags; if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0) return (EOF); if (flags & O_NONBLOCK) { flags &= ~O_NONBLOCK; fcntl (fileno (stream), F_SETFL, flags); continue; } } #endif /* _POSIX_VERSION && EAGAIN && O_NONBLOCK */ #if !defined (__GO32__) /* If the error that we received was SIGINT, then try again, this is simply an interrupted system call to read (). Otherwise, some error ocurred, also signifying EOF. */ if (errno != EINTR) return (EOF); #endif /* !__GO32__ */ } } #if !defined (SHELL) #ifdef savestring #undef savestring #endif /* Backwards compatibilty, now that savestring has been removed from all `public' readline header files. */ char * savestring (s) char *s; { return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s))); } #endif /* Function equivalents for the macros defined in chartypes.h. */ #undef uppercase_p int uppercase_p (c) int c; { return (isupper (c)); } #undef lowercase_p int lowercase_p (c) int c; { return (islower (c)); } #undef pure_alphabetic int pure_alphabetic (c) int c; { return (isupper (c) || islower (c)); } #undef digit_p int digit_p (c) int c; { return (isdigit (c)); } #undef to_lower int to_lower (c) int c; { return (isupper (c) ? tolower (c) : c); } #undef to_upper int to_upper (c) int c; { return (islower (c) ? toupper (c) : c); } #undef digit_value int digit_value (c) int c; { return (isdigit (c) ? c - '0' : c); } #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Testing Readline */ /* */ /* **************************************************************** */ #if defined (TEST) main () { HIST_ENTRY **history_list (); char *temp = (char *)NULL; char *prompt = "readline% "; int done = 0; while (!done) { temp = readline (prompt); /* Test for EOF. */ if (!temp) exit (1); /* If there is anything on the line, print it and remember it. */ if (*temp) { fprintf (stderr, "%s\r\n", temp); add_history (temp); } /* Check for `command' that we handle. */ if (strcmp (temp, "quit") == 0) done = 1; if (strcmp (temp, "list") == 0) { HIST_ENTRY **list = history_list (); register int i; if (list) { for (i = 0; list[i]; i++) { fprintf (stderr, "%d: %s\r\n", i, list[i]->line); free (list[i]->line); } free (list); } } free (temp); } } #endif /* TEST */ /* * Local variables: * compile-command: "gcc -g -traditional -I. -I.. -DTEST -o readline readline.c keymaps.o funmap.o history.o -ltermcap" * end: */ @ 1.1 log @Initial revision @ text @d1181 5 a1185 1 extern char PC, *BC, *UP; @ lafe/readline/RCS/configure,v100555 325 24 104557 6106101040 14340 0ustar dlduserhead 1.1; access; symbols; locks dld:1.1; strict; comment @# @; 1.1 date 95.11.25.07.03.37; author dld; state Exp; branches; next ; desc @@ 1.1 log @Initial revision @ text @#!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 1.11 # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # This configure script is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as published # by the Free Software Foundation; either version 2, or (at your option) # any later version. # This script is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Save the original args to write them into config.status later. configure_args="$*" # Only options that might do something get documented. ac_usage="Usage: configure [options] [host] Options: [defaults in brackets after descriptions] --build=BUILD configure for building on BUILD [BUILD=HOST] --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --exec-prefix=PREFIX install host dependent files in PREFIX [/usr/local] --help print this message --host=HOST configure for HOST [guessed] --prefix=PREFIX install host independent files in PREFIX [/usr/local] --quiet, --silent do not print \`checking for...' messages --srcdir=DIR find the sources in DIR [configure dir or ..] --target=TARGET configure for TARGET [TARGET=HOST] --verbose print results of checks --version print the version of autoconf that created configure --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --x-includes=DIR X include files are in DIR --x-libraries=DIR X library files are in DIR" # Initialize some variables set by options. # The variables have the same names as the options, with # dashes changed to underlines. build=NONE exec_prefix= host=NONE no_create= nonopt=NONE norecursion= prefix= program_prefix= program_suffix= program_transform_name= silent= srcdir= target=NONE verbose= x_includes= x_libraries= ac_prev= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval "$ac_prev=\$ac_option" ac_prev= continue fi # Accept (but ignore some of) the important Cygnus configure # options, so we can diagnose typos. case "$ac_option" in -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) ac_optarg= ;; esac case "$ac_option" in -build | --build | --buil | --bui | --bu | --b) ac_prev=build ;; -build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*) build="$ac_optarg" ;; -disable-* | --disable-*) ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` eval "enable_${ac_feature}=no" ;; -enable-* | --enable-*) ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "enable_${ac_feature}='$ac_optarg'" ;; # For backward compatibility, recognize -exec-prefix and --exec_prefix. -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix="$ac_optarg" ;; -gas | --gas | --ga | --g) with_gas=yes ;; # Obsolete; use --with-gas. -help | --help | --hel | --he) cat << EOF $ac_usage EOF exit 0 ;; -host | --host | --hos | --ho) ac_prev=host ;; -host=* | --host=* | --hos=* | --ho=*) host="$ac_optarg" ;; -nfp | --nfp | --nf) with_fp=no ;; # Obsolete; use --without-fp. -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) norecursion=yes ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix="$ac_optarg" ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix="$ac_optarg" ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix="$ac_optarg" ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name="$ac_optarg" ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir="$ac_optarg" ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target="$ac_optarg" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers) echo "configure generated by autoconf version 1.11" exit 0 ;; -with-* | --with-*) ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "with_${ac_package}='$ac_optarg'" ;; -without-* | --without-*) ac_package=`echo $ac_option|sed -e 's/-*without-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` eval "with_${ac_package}=no" ;; --x) with_x=yes ;; # Obsolete; use --with-x. -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes="$ac_optarg" ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries="$ac_optarg" ;; -*) echo "configure: $ac_option: invalid option; use --help to show usage" >&2; exit 1 ;; *) if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then echo "configure: warning: $ac_option: invalid host type" >&2 fi if test "x$nonopt" != xNONE; then echo "configure: can only configure for one host and one target at a time" >&2; exit 1 fi nonopt="$ac_option" ;; esac done if test -n "$ac_prev"; then echo "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" >&2; exit 1 fi trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 2 15 trap 'rm -fr confdefs* $ac_clean_files' 0 # Save the original args if we used an alternate arg parser. ac_configure_temp="${configure_args-$*}" # Strip out --no-create and --norecursion so they don't pile up. configure_args= for ac_arg in $ac_configure_temp; do case "$ac_arg" in -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) ;; *) configure_args="$configure_args $ac_arg" ;; esac done # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set'; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set'; then LANG=C; export LANG; fi # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. ac_unique_file=readline.h # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then `..'. ac_prog=$0 ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. srcdir=$ac_confdir if test ! -r $srcdir/$ac_unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$ac_unique_file; then if test x$ac_srcdir_defaulted = xyes; then echo "configure: can not find sources in ${ac_confdir} or .." >&2; exit 1 else echo "configure: can not find sources in ${srcdir}" >&2; exit 1 fi fi ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='${CPP}' ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1' #!/bin/sh # From configure.in Configure for Readline 2.0 # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g auto_cflags=1 if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set ac_dummy gcc; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then CC="gcc" break fi done IFS="$ac_save_ifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* # If we're using gcc and the user hasn't specified CFLAGS, add -O to CFLAGS. test -n "$GCC" && test -n "$auto_cflags" && CFLAGS="$CFLAGS -O" test -n "$silent" || echo "checking how to run the C preprocessor" if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* fi test -n "$verbose" && echo " setting CPP to $CPP" if test -n "$GCC"; then test -n "$silent" || echo "checking whether -traditional is needed" ac_pattern="Autoconf.*'x'" ac_prog='#include Autoconf TIOCGETP' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* if test -z "$ac_need_trad"; then ac_prog='#include Autoconf TCGETA' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* fi test -n "$ac_need_trad" && CC="$CC -traditional" fi if test -z "$RANLIB"; then # Extract the first word of `ranlib', so it can be a program name with args. set ac_dummy ranlib; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then RANLIB="ranlib" break fi done IFS="$ac_save_ifs" fi test -z "$RANLIB" && RANLIB=":" test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB" test -n "$silent" || echo "checking for BSD string and memory functions" cat > conftest.${ac_ext} < int main() { return 0; } int t() { rindex(0, 0); bzero(0, 0);; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining USG" echo "#define" USG "1" >> confdefs.h DEFS="$DEFS -DUSG=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}USG\${ac_dB}USG\${ac_dC}1\${ac_dD} \${ac_uA}USG\${ac_uB}USG\${ac_uC}1\${ac_uD} \${ac_eA}USG\${ac_eB}USG\${ac_eC}1\${ac_eD} " } fi rm -f conftest* for ac_func in strcasecmp sighold do ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_func}" echo "#define" ${ac_tr_func} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_func}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done for ac_hdr in unistd.h stdlib.h varargs.h string.h alloca.h \ dirent.h sys/ptem.h sys/pte.h sys/stream.h termcap.h \ termio.h do ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./' '[A-Z]__'` test -n "$silent" || echo "checking for ${ac_hdr}" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_hdr}" echo "#define" ${ac_tr_hdr} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_hdr}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_hdr}\${ac_dB}${ac_tr_hdr}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_hdr}\${ac_uB}${ac_tr_hdr}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_hdr}\${ac_eB}${ac_tr_hdr}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done test -n "$silent" || echo "checking for sys/file.h" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining NO_SYS_FILE" echo "#define" NO_SYS_FILE "1" >> confdefs.h DEFS="$DEFS -DNO_SYS_FILE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}NO_SYS_FILE\${ac_dB}NO_SYS_FILE\${ac_dC}1\${ac_dD} \${ac_uA}NO_SYS_FILE\${ac_uB}NO_SYS_FILE\${ac_uC}1\${ac_uD} \${ac_eA}NO_SYS_FILE\${ac_eB}NO_SYS_FILE\${ac_eC}1\${ac_eD} " } fi rm -f conftest* if test -z "$have_tiocgwinsz"; then test -n "$silent" || echo "checking for TIOCGWINSZ in sys/ioctl.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { int x = TIOCGWINSZ;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining GWINSZ_IN_SYS_IOCTL" echo "#define" GWINSZ_IN_SYS_IOCTL "1" >> confdefs.h DEFS="$DEFS -DGWINSZ_IN_SYS_IOCTL=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}GWINSZ_IN_SYS_IOCTL\${ac_dB}GWINSZ_IN_SYS_IOCTL\${ac_dC}1\${ac_dD} \${ac_uA}GWINSZ_IN_SYS_IOCTL\${ac_uB}GWINSZ_IN_SYS_IOCTL\${ac_uC}1\${ac_uD} \${ac_eA}GWINSZ_IN_SYS_IOCTL\${ac_eB}GWINSZ_IN_SYS_IOCTL\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi test -n "$silent" || echo "checking for programs able to redeclare getpw functions" cat > conftest.${ac_ext} < #include extern struct passwd *getpwuid(); int main() { return 0; } int t() { struct passwd *z; z = getpwuid(0);; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_GETPW_DECLS" echo "#define" HAVE_GETPW_DECLS "1" >> confdefs.h DEFS="$DEFS -DHAVE_GETPW_DECLS=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GETPW_DECLS\${ac_dB}HAVE_GETPW_DECLS\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_GETPW_DECLS\${ac_uB}HAVE_GETPW_DECLS\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_GETPW_DECLS\${ac_eB}HAVE_GETPW_DECLS\${ac_eC}1\${ac_eD} " } fi rm -f conftest* # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! test -n "$silent" || echo "checking for working alloca.h" cat > conftest.${ac_ext} < int main() { return 0; } int t() { char *p = alloca(2 * sizeof(int));; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define" HAVE_ALLOCA_H "1" >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA_H\${ac_dB}HAVE_ALLOCA_H\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA_H\${ac_uB}HAVE_ALLOCA_H\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA_H\${ac_eB}HAVE_ALLOCA_H\${ac_eC}1\${ac_eD} " } fi rm -f conftest* ac_decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " test -n "$silent" || echo "checking for alloca" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA\${ac_dB}HAVE_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA\${ac_uB}HAVE_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA\${ac_eB}HAVE_ALLOCA\${ac_eC}1\${ac_eD} " } else rm -rf conftest* ac_alloca_missing=1 cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then rm -rf conftest* test -n "$silent" || echo "checking for _getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "_getb67" echo "#define" CRAY_STACKSEG_END "_getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}_getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}_getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}_getb67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for GETB67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "GETB67" echo "#define" CRAY_STACKSEG_END "GETB67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}GETB67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}GETB67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}GETB67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "getb67" echo "#define" CRAY_STACKSEG_END "getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}getb67\${ac_eD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$ac_alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define" C_ALLOCA "1" >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}C_ALLOCA\${ac_dB}C_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}C_ALLOCA\${ac_uB}C_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}C_ALLOCA\${ac_eB}C_ALLOCA\${ac_eC}1\${ac_eD} " } test -n "$silent" || echo "checking stack direction for C alloca" test -n "$silent" || echo "checking whether cross-compiling" # If we cannot run a trivial program, we must be cross compiling. cat > conftest.${ac_ext} </dev/null; then : else cross_compiling=1 fi rm -fr conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "0" echo "#define" STACK_DIRECTION "0" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}0\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}0\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}0\${ac_eD} " } else cat > conftest.${ac_ext} < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $ac_compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "1" echo "#define" STACK_DIRECTION "1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}1\${ac_eD} " } else { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "-1" echo "#define" STACK_DIRECTION "-1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}-1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}-1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}-1\${ac_eD} " } fi fi rm -fr conftest* fi # The preferred way to propogate these variables is regular @@ substitutions. if test -n "$prefix"; then ac_prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" else prefix=/usr/local fi if test -n "$exec_prefix"; then ac_prsub="$ac_prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" else exec_prefix='${prefix}' # Let make expand it. fi # Any assignment to VPATH causes Sun make to only execute # the first set of double-colon rules, so remove it if not needed. # If there is a colon in the path, we need to keep it. if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args ac_cs_usage="Usage: config.status [--recheck] [--version] [--help]" for ac_option do case "\$ac_option" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "config.status generated by autoconf version 1.11" exit 0 ;; -help | --help | --hel | --he | --h) echo "\$ac_cs_usage"; exit 0 ;; *) echo "\$ac_cs_usage"; exit 1 ;; esac done trap 'rm -fr Makefile config.h conftest*; exit 1' 1 2 15 CC='$CC' CFLAGS='$CFLAGS' LDFLAGS='$LDFLAGS' CPP='$CPP' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' RANLIB='$RANLIB' ALLOCA='$ALLOCA' LIBS='$LIBS' srcdir='$srcdir' top_srcdir='$top_srcdir' prefix='$prefix' exec_prefix='$exec_prefix' ac_prsub='$ac_prsub' ac_vpsub='$ac_vpsub' extrasub='$extrasub' EOF cat >> config.status <<\EOF ac_given_srcdir=$srcdir CONFIG_FILES=${CONFIG_FILES-"Makefile"} for ac_file in .. ${CONFIG_FILES}; do if test "x$ac_file" != x..; then # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" ac_dir_suffix="/$ac_dir" else ac_dir_suffix= fi # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dir_suffix"; then top_srcdir=. else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; *) # Relative path. srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" top_srcdir="$ac_dots$ac_given_srcdir" ;; esac echo creating "$ac_file" rm -f "$ac_file" comment_str="Generated automatically from `echo $ac_file|sed 's|.*/||'`.in by configure." case "$ac_file" in *.c | *.h | *.C | *.cc | *.m ) echo "/* $comment_str */" > "$ac_file" ;; * ) echo "# $comment_str" > "$ac_file" ;; esac sed -e " $ac_prsub $ac_vpsub $extrasub s%@@CC@@%$CC%g s%@@CFLAGS@@%$CFLAGS%g s%@@LDFLAGS@@%$LDFLAGS%g s%@@CPP@@%$CPP%g s%@@INSTALL@@%$INSTALL%g s%@@INSTALL_PROGRAM@@%$INSTALL_PROGRAM%g s%@@INSTALL_DATA@@%$INSTALL_DATA%g s%@@RANLIB@@%$RANLIB%g s%@@ALLOCA@@%$ALLOCA%g s%@@LIBS@@%$LIBS%g s%@@srcdir@@%$srcdir%g s%@@top_srcdir@@%$top_srcdir%g s%@@prefix@@%$prefix%g s%@@exec_prefix@@%$exec_prefix%g s%@@DEFS@@%-DHAVE_CONFIG_H%" $ac_given_srcdir/${ac_file}.in >> $ac_file fi; done # These sed commands are put into ac_sed_defs when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # Hopefully no one uses "!" as a variable value. # Other candidates for the sed separators, like , and @@, do get used. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s!^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='\([ ][ ]*\)[^ ]*!\1#\2' ac_dC='\3' ac_dD='!g' # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_uA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='\([ ]\)!\1#\2define\3' ac_uC=' ' ac_uD='\4!g' # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_eA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_eB='$!\1#\2define\3' ac_eC=' ' ac_eD='!g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -9. sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +10. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # config.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. ac_max_sed_lines=20 CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"} for ac_file in .. ${CONFIG_HEADERS}; do if test "x$ac_file" != x..; then echo creating $ac_file cp $ac_given_srcdir/$ac_file.in conftest.h1 cp conftest.sed conftest.stm while : do ac_lines=`grep -c . conftest.stm` if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${ac_max_sed_lines}q conftest.stm > conftest.s1 # Like head -20. sed 1,${ac_max_sed_lines}d conftest.stm > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.stm mv conftest.h2 conftest.h1 mv conftest.s2 conftest.stm done rm -f conftest.stm conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $ac_file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. echo "$ac_file is unchanged" rm -f conftest.h else rm -f $ac_file mv conftest.h $ac_file fi fi; done rm -f conftest.sed # Makefile uses this timestamp file to record whether config.h is up to date. touch stamp-config exit 0 EOF chmod +x config.status # Some shells look in PATH for config.status without the "./". test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} ./config.status @ lafe/readline/RCS/chardefs.h,v100444 325 24 6730 6106101040 14313 0ustar dlduserhead 1.2; access; symbols; locks; strict; comment @ * @; 1.2 date 95.11.25.07.38.40; author dld; state Exp; branches; next 1.1; 1.1 date 95.11.25.07.13.02; author dld; state Exp; branches; next ; desc @@ 1.2 log @included rldefs.h for string dependency @ text @/* chardefs.h -- Character definitions for readline. */ /* Copyright (C) 1994 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _CHARDEFS_H #define _CHARDEFS_H #include #include "rldefs.h" #if defined (HAVE_STRING_H) # include #else # include #endif /* HAVE_STRING_H */ #ifndef whitespace #define whitespace(c) (((c) == ' ') || ((c) == '\t')) #endif #ifdef CTRL #undef CTRL #endif /* Some character stuff. */ #define control_character_threshold 0x020 /* Smaller than this is control. */ #define control_character_mask 0x1f /* 0x20 - 1 */ #define meta_character_threshold 0x07f /* Larger than this is Meta. */ #define control_character_bit 0x40 /* 0x000000, must be off. */ #define meta_character_bit 0x080 /* x0000000, must be on. */ #define largest_char 255 /* Largest character value. */ #define CTRL_CHAR(c) ((c) < control_character_threshold) #define META_CHAR(c) ((c) > meta_character_threshold && (c) <= largest_char) #define CTRL(c) ((c) & control_character_mask) #define META(c) ((c) | meta_character_bit) #define UNMETA(c) ((c) & (~meta_character_bit)) #define UNCTRL(c) to_upper(((c)|control_character_bit)) /* Old versions #define lowercase_p(c) (((c) > ('a' - 1) && (c) < ('z' + 1))) #define uppercase_p(c) (((c) > ('A' - 1) && (c) < ('Z' + 1))) #define digit_p(c) ((c) >= '0' && (c) <= '9') */ #define lowercase_p(c) (islower(c)) #define uppercase_p(c) (isupper(c)) #define digit_p(x) (isdigit (x)) #define pure_alphabetic(c) (lowercase_p(c) || uppercase_p(c)) /* Old versions # define to_upper(c) (lowercase_p(c) ? ((c) - 32) : (c)) # define to_lower(c) (uppercase_p(c) ? ((c) + 32) : (c)) */ #ifndef to_upper # define to_upper(c) (islower(c) ? toupper(c) : (c)) # define to_lower(c) (isupper(c) ? tolower(c) : (c)) #endif #ifndef digit_value #define digit_value(x) ((x) - '0') #endif #ifndef NEWLINE #define NEWLINE '\n' #endif #ifndef RETURN #define RETURN CTRL('M') #endif #ifndef RUBOUT #define RUBOUT 0x7f #endif #ifndef TAB #define TAB '\t' #endif #ifdef ABORT_CHAR #undef ABORT_CHAR #endif #define ABORT_CHAR CTRL('G') #ifdef PAGE #undef PAGE #endif #define PAGE CTRL('L') #ifdef SPACE #undef SPACE #endif #define SPACE ' ' /* XXX - was 0x20 */ #ifdef ESC #undef ESC #endif #define ESC CTRL('[') #endif /* _CHARDEFS_H */ @ 1.1 log @Initial revision @ text @d28 2 @ lafe/readline/RCS/tilde.c,v100444 325 24 23336 6106101040 13651 0ustar dlduserhead 1.2; access; symbols; locks; strict; comment @ * @; 1.2 date 95.11.25.07.38.19; author dld; state Exp; branches; next 1.1; 1.1 date 95.11.25.07.15.15; author dld; state Exp; branches; next ; desc @@ 1.2 log @included rldefs.h for string dependency @ text @/* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */ /* Copyright (C) 1988,1989 Free Software Foundation, Inc. This file is part of GNU Readline, a library for reading lines of text with interactive input and history editing. Readline is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. Readline is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Readline; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "memalloc.h" #include "rldefs.h" #if defined (HAVE_STRING_H) # include #else /* !HAVE_STRING_H */ # include #endif /* !HAVE_STRING_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include "tilde.h" #include #if defined (USG) && !defined (HAVE_GETPW_DECLS) extern struct passwd *getpwuid (), *getpwnam (); #endif /* USG && !defined (HAVE_GETPW_DECLS) */ #if !defined (savestring) extern char *xmalloc (); # ifndef strcpy extern char *strcpy (); # endif #define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x)) #endif /* !savestring */ #if !defined (NULL) # if defined (__STDC__) # define NULL ((void *) 0) # else # define NULL 0x0 # endif /* !__STDC__ */ #endif /* !NULL */ #if defined (TEST) || defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* TEST || STATIC_MALLOC */ /* The default value of tilde_additional_prefixes. This is set to whitespace preceding a tilde so that simple programs which do not perform any word separation get desired behaviour. */ static char *default_prefixes[] = { " ~", "\t~", (char *)NULL }; /* The default value of tilde_additional_suffixes. This is set to whitespace or newline so that simple programs which do not perform any word separation get desired behaviour. */ static char *default_suffixes[] = { " ", "\n", (char *)NULL }; /* If non-null, this contains the address of a function to call if the standard meaning for expanding a tilde fails. The function is called with the text (sans tilde, as in "foo"), and returns a malloc()'ed string which is the expansion, or a NULL pointer if there is no expansion. */ CPFunction *tilde_expansion_failure_hook = (CPFunction *)NULL; /* When non-null, this is a NULL terminated array of strings which are duplicates for a tilde prefix. Bash uses this to expand `=~' and `:~'. */ char **tilde_additional_prefixes = default_prefixes; /* When non-null, this is a NULL terminated array of strings which match the end of a username, instead of just "/". Bash sets this to `:' and `=~'. */ char **tilde_additional_suffixes = default_suffixes; /* Find the start of a tilde expansion in STRING, and return the index of the tilde which starts the expansion. Place the length of the text which identified this tilde starter in LEN, excluding the tilde itself. */ static int tilde_find_prefix (string, len) char *string; int *len; { register int i, j, string_len; register char **prefixes = tilde_additional_prefixes; string_len = strlen (string); *len = 0; if (!*string || *string == '~') return (0); if (prefixes) { for (i = 0; i < string_len; i++) { for (j = 0; prefixes[j]; j++) { if (strncmp (string + i, prefixes[j], strlen (prefixes[j])) == 0) { *len = strlen (prefixes[j]) - 1; return (i + *len); } } } } return (string_len); } /* Find the end of a tilde expansion in STRING, and return the index of the character which ends the tilde definition. */ static int tilde_find_suffix (string) char *string; { register int i, j, string_len; register char **suffixes = tilde_additional_suffixes; string_len = strlen (string); for (i = 0; i < string_len; i++) { if (string[i] == '/' || !string[i]) break; for (j = 0; suffixes && suffixes[j]; j++) { if (strncmp (string + i, suffixes[j], strlen (suffixes[j])) == 0) return (i); } } return (i); } /* Return a new string which is the result of tilde expanding STRING. */ char * tilde_expand (string) char *string; { char *result, *tilde_expand_word (); int result_size, result_index; result_size = result_index = 0; result = (char *)NULL; /* Scan through STRING expanding tildes as we come to them. */ while (1) { register int start, end; char *tilde_word, *expansion; int len; /* Make START point to the tilde which starts the expansion. */ start = tilde_find_prefix (string, &len); /* Copy the skipped text into the result. */ if ((result_index + start + 1) > result_size) result = (char *)xrealloc (result, 1 + (result_size += (start + 20))); strncpy (result + result_index, string, start); result_index += start; /* Advance STRING to the starting tilde. */ string += start; /* Make END be the index of one after the last character of the username. */ end = tilde_find_suffix (string); /* If both START and END are zero, we are all done. */ if (!start && !end) break; /* Expand the entire tilde word, and copy it into RESULT. */ tilde_word = (char *)xmalloc (1 + end); strncpy (tilde_word, string, end); tilde_word[end] = '\0'; string += end; expansion = tilde_expand_word (tilde_word); free (tilde_word); len = strlen (expansion); if ((result_index + len + 1) > result_size) result = (char *)xrealloc (result, 1 + (result_size += (len + 20))); strcpy (result + result_index, expansion); result_index += len; free (expansion); } result[result_index] = '\0'; return (result); } /* Do the work of tilde expansion on FILENAME. FILENAME starts with a tilde. If there is no expansion, call tilde_expansion_failure_hook. */ char * tilde_expand_word (filename) char *filename; { char *dirname; dirname = filename ? savestring (filename) : (char *)NULL; if (dirname && *dirname == '~') { char *temp_name; if (!dirname[1] || dirname[1] == '/') { /* Prepend $HOME to the rest of the string. */ char *temp_home = (char *)getenv ("HOME"); /* If there is no HOME variable, look up the directory in the password database. */ if (!temp_home) { struct passwd *entry; entry = getpwuid (getuid ()); if (entry) temp_home = entry->pw_dir; } temp_name = xmalloc (1 + strlen (&dirname[1]) + (temp_home ? strlen (temp_home) : 0)); temp_name[0] = '\0'; if (temp_home) strcpy (temp_name, temp_home); strcat (temp_name, dirname + 1); free (dirname); dirname = temp_name; } else { char u_name[257]; struct passwd *user_entry; char *username; int i, c; username = u_name; for (i = 1; c = dirname[i]; i++) { if (c == '/') break; else username[i - 1] = c; } username[i - 1] = '\0'; if (!(user_entry = getpwnam (username))) { /* If the calling program has a special syntax for expanding tildes, and we couldn't find a standard expansion, then let them try. */ if (tilde_expansion_failure_hook) { char *expansion; expansion = (*tilde_expansion_failure_hook) (username); if (expansion) { temp_name = xmalloc (1 + strlen (expansion) + strlen (&dirname[i])); strcpy (temp_name, expansion); strcat (temp_name, &dirname[i]); free (expansion); free (dirname); dirname = temp_name; } } /* We shouldn't report errors. */ } else { temp_name = xmalloc (1 + strlen (user_entry->pw_dir) + strlen (&dirname[i])); strcpy (temp_name, user_entry->pw_dir); strcat (temp_name, &dirname[i]); free (dirname); dirname = temp_name; } endpwent (); } } return (dirname); } #if defined (TEST) #undef NULL #include main (argc, argv) int argc; char **argv; { char *result, line[512]; int done = 0; while (!done) { printf ("~expand: "); fflush (stdout); if (!gets (line)) strcpy (line, "done"); if ((strcmp (line, "done") == 0) || (strcmp (line, "quit") == 0) || (strcmp (line, "exit") == 0)) { done = 1; break; } result = tilde_expand (line); printf (" --> %s\n", result); free (result); } exit (0); } static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } /* * Local variables: * compile-command: "gcc -g -DTEST -o tilde tilde.c" * end: */ #endif /* TEST */ @ 1.1 log @Initial revision @ text @d23 1 @ lafe/readline/config.h.in100644 325 24 3616 6106101041 13520 0ustar dlduser/* config.h.in. Generated automatically from configure.in by autoheader. */ #ifndef _RL_CONFIG_H #define _RL_CONFIG_H /* Define if using alloca.c. */ #undef C_ALLOCA /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. This function is required for alloca.c support on those systems. */ #undef CRAY_STACKSEG_END /* Define if you have alloca.h and it should be used (not Ultrix). */ #undef HAVE_ALLOCA_H /* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION /* Define if you do not have strings.h, index, bzero, etc.. */ #undef USG /* Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ #undef GWINSZ_IN_SYS_IOCTL #undef HAVE_GETPW_DECLS #undef NO_SYS_FILE /* Define if you have strcasecmp. */ #undef HAVE_STRCASECMP /* Define if you have the header file. */ #undef HAVE_ALLOCA_H /* Define if you have the header file. */ #undef HAVE_DIRENT_H /* Define if you have the header file. */ #undef HAVE_STDLIB_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_PTE_H /* Define if you have the header file. */ #undef HAVE_SYS_PTEM_H /* Define if you have the header file. */ #undef HAVE_SYS_STREAM_H /* Define if you have the header file. */ #undef HAVE_TERMCAP_H /* Define if you have the header file. */ #undef HAVE_TERMIO_H /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have the header file. */ #undef HAVE_VARARGS_H #endif lafe/readline/vi_keymap.c100644 325 24 100263 6106101041 13661 0ustar dlduser/* vi_keymap.c -- the keymap for vi_mode in readline (). */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (BUFSIZ) #include #endif /* !BUFSIZ */ #include "readline.h" #if 0 extern KEYMAP_ENTRY_ARRAY vi_escape_keymap; #endif /* The keymap arrays for handling vi mode. */ KEYMAP_ENTRY_ARRAY vi_movement_keymap = { /* The regular control keys come first. */ { ISFUNC, (Function *)0x0 }, /* Control-@ */ { ISFUNC, (Function *)0x0 }, /* Control-a */ { ISFUNC, (Function *)0x0 }, /* Control-b */ { ISFUNC, (Function *)0x0 }, /* Control-c */ { ISFUNC, rl_vi_eof_maybe }, /* Control-d */ { ISFUNC, rl_emacs_editing_mode }, /* Control-e */ { ISFUNC, (Function *)0x0 }, /* Control-f */ { ISFUNC, rl_abort }, /* Control-g */ { ISFUNC, rl_backward }, /* Control-h */ { ISFUNC, (Function *)0x0 }, /* Control-i */ { ISFUNC, rl_newline }, /* Control-j */ { ISFUNC, rl_kill_line }, /* Control-k */ { ISFUNC, rl_clear_screen }, /* Control-l */ { ISFUNC, rl_newline }, /* Control-m */ { ISFUNC, rl_get_next_history }, /* Control-n */ { ISFUNC, (Function *)0x0 }, /* Control-o */ { ISFUNC, rl_get_previous_history }, /* Control-p */ { ISFUNC, rl_quoted_insert }, /* Control-q */ { ISFUNC, rl_reverse_search_history }, /* Control-r */ { ISFUNC, rl_forward_search_history }, /* Control-s */ { ISFUNC, rl_transpose_chars }, /* Control-t */ { ISFUNC, rl_unix_line_discard }, /* Control-u */ { ISFUNC, rl_quoted_insert }, /* Control-v */ { ISFUNC, rl_unix_word_rubout }, /* Control-w */ { ISFUNC, (Function *)0x0 }, /* Control-x */ { ISFUNC, rl_yank }, /* Control-y */ { ISFUNC, (Function *)0x0 }, /* Control-z */ { ISFUNC, (Function *)0x0 }, /* Control-[ */ /* vi_escape_keymap */ { ISFUNC, (Function *)0x0 }, /* Control-\ */ { ISFUNC, (Function *)0x0 }, /* Control-] */ { ISFUNC, (Function *)0x0 }, /* Control-^ */ { ISFUNC, rl_undo_command }, /* Control-_ */ /* The start of printing characters. */ { ISFUNC, rl_forward }, /* SPACE */ { ISFUNC, (Function *)0x0 }, /* ! */ { ISFUNC, (Function *)0x0 }, /* " */ { ISFUNC, rl_vi_comment }, /* # */ { ISFUNC, rl_end_of_line }, /* $ */ { ISFUNC, rl_vi_match }, /* % */ { ISFUNC, rl_vi_tilde_expand }, /* & */ { ISFUNC, (Function *)0x0 }, /* ' */ { ISFUNC, (Function *)0x0 }, /* ( */ { ISFUNC, (Function *)0x0 }, /* ) */ { ISFUNC, rl_vi_complete }, /* * */ { ISFUNC, rl_get_next_history}, /* + */ { ISFUNC, rl_vi_char_search }, /* , */ { ISFUNC, rl_get_previous_history }, /* - */ { ISFUNC, rl_vi_redo }, /* . */ { ISFUNC, rl_vi_search }, /* / */ /* Regular digits. */ { ISFUNC, rl_beg_of_line }, /* 0 */ { ISFUNC, rl_vi_arg_digit }, /* 1 */ { ISFUNC, rl_vi_arg_digit }, /* 2 */ { ISFUNC, rl_vi_arg_digit }, /* 3 */ { ISFUNC, rl_vi_arg_digit }, /* 4 */ { ISFUNC, rl_vi_arg_digit }, /* 5 */ { ISFUNC, rl_vi_arg_digit }, /* 6 */ { ISFUNC, rl_vi_arg_digit }, /* 7 */ { ISFUNC, rl_vi_arg_digit }, /* 8 */ { ISFUNC, rl_vi_arg_digit }, /* 9 */ /* A little more punctuation. */ { ISFUNC, (Function *)0x0 }, /* : */ { ISFUNC, rl_vi_char_search }, /* ; */ { ISFUNC, (Function *)0x0 }, /* < */ { ISFUNC, rl_vi_complete }, /* = */ { ISFUNC, (Function *)0x0 }, /* > */ { ISFUNC, rl_vi_search }, /* ? */ { ISFUNC, (Function *)0x0 }, /* @ */ /* Uppercase alphabet. */ { ISFUNC, rl_vi_append_eol }, /* A */ { ISFUNC, rl_vi_prev_word}, /* B */ { ISFUNC, rl_vi_change_to }, /* C */ { ISFUNC, rl_vi_delete_to }, /* D */ { ISFUNC, rl_vi_end_word }, /* E */ { ISFUNC, rl_vi_char_search }, /* F */ { ISFUNC, rl_vi_fetch_history }, /* G */ { ISFUNC, (Function *)0x0 }, /* H */ { ISFUNC, rl_vi_insert_beg }, /* I */ { ISFUNC, (Function *)0x0 }, /* J */ { ISFUNC, (Function *)0x0 }, /* K */ { ISFUNC, (Function *)0x0 }, /* L */ { ISFUNC, (Function *)0x0 }, /* M */ { ISFUNC, rl_vi_search_again }, /* N */ { ISFUNC, (Function *)0x0 }, /* O */ { ISFUNC, rl_vi_put }, /* P */ { ISFUNC, (Function *)0x0 }, /* Q */ { ISFUNC, rl_vi_replace }, /* R */ { ISFUNC, rl_vi_subst }, /* S */ { ISFUNC, rl_vi_char_search }, /* T */ { ISFUNC, rl_revert_line }, /* U */ { ISFUNC, (Function *)0x0 }, /* V */ { ISFUNC, rl_vi_next_word }, /* W */ { ISFUNC, rl_rubout }, /* X */ { ISFUNC, rl_vi_yank_to }, /* Y */ { ISFUNC, (Function *)0x0 }, /* Z */ /* Some more punctuation. */ { ISFUNC, (Function *)0x0 }, /* [ */ { ISFUNC, rl_vi_complete }, /* \ */ { ISFUNC, (Function *)0x0 }, /* ] */ { ISFUNC, rl_vi_first_print }, /* ^ */ { ISFUNC, rl_vi_yank_arg }, /* _ */ { ISFUNC, (Function *)0x0 }, /* ` */ /* Lowercase alphabet. */ { ISFUNC, rl_vi_append_mode }, /* a */ { ISFUNC, rl_vi_prev_word }, /* b */ { ISFUNC, rl_vi_change_to }, /* c */ { ISFUNC, rl_vi_delete_to }, /* d */ { ISFUNC, rl_vi_end_word }, /* e */ { ISFUNC, rl_vi_char_search }, /* f */ { ISFUNC, (Function *)0x0 }, /* g */ { ISFUNC, rl_backward }, /* h */ { ISFUNC, rl_vi_insertion_mode }, /* i */ { ISFUNC, rl_get_next_history }, /* j */ { ISFUNC, rl_get_previous_history }, /* k */ { ISFUNC, rl_forward }, /* l */ { ISFUNC, (Function *)0x0 }, /* m */ { ISFUNC, rl_vi_search_again }, /* n */ { ISFUNC, (Function *)0x0 }, /* o */ { ISFUNC, rl_vi_put }, /* p */ { ISFUNC, (Function *)0x0 }, /* q */ { ISFUNC, rl_vi_change_char }, /* r */ { ISFUNC, rl_vi_subst }, /* s */ { ISFUNC, rl_vi_char_search }, /* t */ { ISFUNC, rl_undo_command }, /* u */ { ISFUNC, (Function *)0x0 }, /* v */ { ISFUNC, rl_vi_next_word }, /* w */ { ISFUNC, rl_vi_delete }, /* x */ { ISFUNC, rl_vi_yank_to }, /* y */ { ISFUNC, (Function *)0x0 }, /* z */ /* Final punctuation. */ { ISFUNC, (Function *)0x0 }, /* { */ { ISFUNC, rl_vi_column }, /* | */ { ISFUNC, (Function *)0x0 }, /* } */ { ISFUNC, rl_vi_change_case }, /* ~ */ { ISFUNC, (Function *)0x0 }, /* RUBOUT */ #if KEYMAP_SIZE > 128 /* Undefined keys. */ { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 } #endif /* KEYMAP_SIZE > 128 */ }; KEYMAP_ENTRY_ARRAY vi_insertion_keymap = { /* The regular control keys come first. */ { ISFUNC, (Function *)0x0 }, /* Control-@ */ { ISFUNC, rl_insert }, /* Control-a */ { ISFUNC, rl_insert }, /* Control-b */ { ISFUNC, rl_insert }, /* Control-c */ { ISFUNC, rl_vi_eof_maybe }, /* Control-d */ { ISFUNC, rl_insert }, /* Control-e */ { ISFUNC, rl_insert }, /* Control-f */ { ISFUNC, rl_insert }, /* Control-g */ { ISFUNC, rl_rubout }, /* Control-h */ { ISFUNC, rl_complete }, /* Control-i */ { ISFUNC, rl_newline }, /* Control-j */ { ISFUNC, rl_insert }, /* Control-k */ { ISFUNC, rl_insert }, /* Control-l */ { ISFUNC, rl_newline }, /* Control-m */ { ISFUNC, rl_insert }, /* Control-n */ { ISFUNC, rl_insert }, /* Control-o */ { ISFUNC, rl_insert }, /* Control-p */ { ISFUNC, rl_insert }, /* Control-q */ { ISFUNC, rl_reverse_search_history }, /* Control-r */ { ISFUNC, rl_forward_search_history }, /* Control-s */ { ISFUNC, rl_transpose_chars }, /* Control-t */ { ISFUNC, rl_unix_line_discard }, /* Control-u */ { ISFUNC, rl_quoted_insert }, /* Control-v */ { ISFUNC, rl_unix_word_rubout }, /* Control-w */ { ISFUNC, rl_insert }, /* Control-x */ { ISFUNC, rl_yank }, /* Control-y */ { ISFUNC, rl_insert }, /* Control-z */ { ISFUNC, rl_vi_movement_mode }, /* Control-[ */ { ISFUNC, rl_insert }, /* Control-\ */ { ISFUNC, rl_insert }, /* Control-] */ { ISFUNC, rl_insert }, /* Control-^ */ { ISFUNC, rl_undo_command }, /* Control-_ */ /* The start of printing characters. */ { ISFUNC, rl_insert }, /* SPACE */ { ISFUNC, rl_insert }, /* ! */ { ISFUNC, rl_insert }, /* " */ { ISFUNC, rl_insert }, /* # */ { ISFUNC, rl_insert }, /* $ */ { ISFUNC, rl_insert }, /* % */ { ISFUNC, rl_insert }, /* & */ { ISFUNC, rl_insert }, /* ' */ { ISFUNC, rl_insert }, /* ( */ { ISFUNC, rl_insert }, /* ) */ { ISFUNC, rl_insert }, /* * */ { ISFUNC, rl_insert }, /* + */ { ISFUNC, rl_insert }, /* , */ { ISFUNC, rl_insert }, /* - */ { ISFUNC, rl_insert }, /* . */ { ISFUNC, rl_insert }, /* / */ /* Regular digits. */ { ISFUNC, rl_insert }, /* 0 */ { ISFUNC, rl_insert }, /* 1 */ { ISFUNC, rl_insert }, /* 2 */ { ISFUNC, rl_insert }, /* 3 */ { ISFUNC, rl_insert }, /* 4 */ { ISFUNC, rl_insert }, /* 5 */ { ISFUNC, rl_insert }, /* 6 */ { ISFUNC, rl_insert }, /* 7 */ { ISFUNC, rl_insert }, /* 8 */ { ISFUNC, rl_insert }, /* 9 */ /* A little more punctuation. */ { ISFUNC, rl_insert }, /* : */ { ISFUNC, rl_insert }, /* ; */ { ISFUNC, rl_insert }, /* < */ { ISFUNC, rl_insert }, /* = */ { ISFUNC, rl_insert }, /* > */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* @ */ /* Uppercase alphabet. */ { ISFUNC, rl_insert }, /* A */ { ISFUNC, rl_insert }, /* B */ { ISFUNC, rl_insert }, /* C */ { ISFUNC, rl_insert }, /* D */ { ISFUNC, rl_insert }, /* E */ { ISFUNC, rl_insert }, /* F */ { ISFUNC, rl_insert }, /* G */ { ISFUNC, rl_insert }, /* H */ { ISFUNC, rl_insert }, /* I */ { ISFUNC, rl_insert }, /* J */ { ISFUNC, rl_insert }, /* K */ { ISFUNC, rl_insert }, /* L */ { ISFUNC, rl_insert }, /* M */ { ISFUNC, rl_insert }, /* N */ { ISFUNC, rl_insert }, /* O */ { ISFUNC, rl_insert }, /* P */ { ISFUNC, rl_insert }, /* Q */ { ISFUNC, rl_insert }, /* R */ { ISFUNC, rl_insert }, /* S */ { ISFUNC, rl_insert }, /* T */ { ISFUNC, rl_insert }, /* U */ { ISFUNC, rl_insert }, /* V */ { ISFUNC, rl_insert }, /* W */ { ISFUNC, rl_insert }, /* X */ { ISFUNC, rl_insert }, /* Y */ { ISFUNC, rl_insert }, /* Z */ /* Some more punctuation. */ { ISFUNC, rl_insert }, /* [ */ { ISFUNC, rl_insert }, /* \ */ { ISFUNC, rl_insert }, /* ] */ { ISFUNC, rl_insert }, /* ^ */ { ISFUNC, rl_insert }, /* _ */ { ISFUNC, rl_insert }, /* ` */ /* Lowercase alphabet. */ { ISFUNC, rl_insert }, /* a */ { ISFUNC, rl_insert }, /* b */ { ISFUNC, rl_insert }, /* c */ { ISFUNC, rl_insert }, /* d */ { ISFUNC, rl_insert }, /* e */ { ISFUNC, rl_insert }, /* f */ { ISFUNC, rl_insert }, /* g */ { ISFUNC, rl_insert }, /* h */ { ISFUNC, rl_insert }, /* i */ { ISFUNC, rl_insert }, /* j */ { ISFUNC, rl_insert }, /* k */ { ISFUNC, rl_insert }, /* l */ { ISFUNC, rl_insert }, /* m */ { ISFUNC, rl_insert }, /* n */ { ISFUNC, rl_insert }, /* o */ { ISFUNC, rl_insert }, /* p */ { ISFUNC, rl_insert }, /* q */ { ISFUNC, rl_insert }, /* r */ { ISFUNC, rl_insert }, /* s */ { ISFUNC, rl_insert }, /* t */ { ISFUNC, rl_insert }, /* u */ { ISFUNC, rl_insert }, /* v */ { ISFUNC, rl_insert }, /* w */ { ISFUNC, rl_insert }, /* x */ { ISFUNC, rl_insert }, /* y */ { ISFUNC, rl_insert }, /* z */ /* Final punctuation. */ { ISFUNC, rl_insert }, /* { */ { ISFUNC, rl_insert }, /* | */ { ISFUNC, rl_insert }, /* } */ { ISFUNC, rl_insert }, /* ~ */ { ISFUNC, rl_rubout }, /* RUBOUT */ #if KEYMAP_SIZE > 128 /* Pure 8-bit characters (128 - 159). These might be used in some character sets. */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ /* ISO Latin-1 characters (160 - 255) */ { ISFUNC, rl_insert }, /* No-break space */ { ISFUNC, rl_insert }, /* Inverted exclamation mark */ { ISFUNC, rl_insert }, /* Cent sign */ { ISFUNC, rl_insert }, /* Pound sign */ { ISFUNC, rl_insert }, /* Currency sign */ { ISFUNC, rl_insert }, /* Yen sign */ { ISFUNC, rl_insert }, /* Broken bar */ { ISFUNC, rl_insert }, /* Section sign */ { ISFUNC, rl_insert }, /* Diaeresis */ { ISFUNC, rl_insert }, /* Copyright sign */ { ISFUNC, rl_insert }, /* Feminine ordinal indicator */ { ISFUNC, rl_insert }, /* Left pointing double angle quotation mark */ { ISFUNC, rl_insert }, /* Not sign */ { ISFUNC, rl_insert }, /* Soft hyphen */ { ISFUNC, rl_insert }, /* Registered sign */ { ISFUNC, rl_insert }, /* Macron */ { ISFUNC, rl_insert }, /* Degree sign */ { ISFUNC, rl_insert }, /* Plus-minus sign */ { ISFUNC, rl_insert }, /* Superscript two */ { ISFUNC, rl_insert }, /* Superscript three */ { ISFUNC, rl_insert }, /* Acute accent */ { ISFUNC, rl_insert }, /* Micro sign */ { ISFUNC, rl_insert }, /* Pilcrow sign */ { ISFUNC, rl_insert }, /* Middle dot */ { ISFUNC, rl_insert }, /* Cedilla */ { ISFUNC, rl_insert }, /* Superscript one */ { ISFUNC, rl_insert }, /* Masculine ordinal indicator */ { ISFUNC, rl_insert }, /* Right pointing double angle quotation mark */ { ISFUNC, rl_insert }, /* Vulgar fraction one quarter */ { ISFUNC, rl_insert }, /* Vulgar fraction one half */ { ISFUNC, rl_insert }, /* Vulgar fraction three quarters */ { ISFUNC, rl_insert }, /* Inverted questionk mark */ { ISFUNC, rl_insert }, /* Latin capital letter a with grave */ { ISFUNC, rl_insert }, /* Latin capital letter a with acute */ { ISFUNC, rl_insert }, /* Latin capital letter a with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter a with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter a with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter a with ring above */ { ISFUNC, rl_insert }, /* Latin capital letter ae */ { ISFUNC, rl_insert }, /* Latin capital letter c with cedilla */ { ISFUNC, rl_insert }, /* Latin capital letter e with grave */ { ISFUNC, rl_insert }, /* Latin capital letter e with acute */ { ISFUNC, rl_insert }, /* Latin capital letter e with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter e with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter i with grave */ { ISFUNC, rl_insert }, /* Latin capital letter i with acute */ { ISFUNC, rl_insert }, /* Latin capital letter i with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter i with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter eth (Icelandic) */ { ISFUNC, rl_insert }, /* Latin capital letter n with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter o with grave */ { ISFUNC, rl_insert }, /* Latin capital letter o with acute */ { ISFUNC, rl_insert }, /* Latin capital letter o with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter o with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter o with diaeresis */ { ISFUNC, rl_insert }, /* Multiplication sign */ { ISFUNC, rl_insert }, /* Latin capital letter o with stroke */ { ISFUNC, rl_insert }, /* Latin capital letter u with grave */ { ISFUNC, rl_insert }, /* Latin capital letter u with acute */ { ISFUNC, rl_insert }, /* Latin capital letter u with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter u with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter Y with acute */ { ISFUNC, rl_insert }, /* Latin capital letter thorn (Icelandic) */ { ISFUNC, rl_insert }, /* Latin small letter sharp s (German) */ { ISFUNC, rl_insert }, /* Latin small letter a with grave */ { ISFUNC, rl_insert }, /* Latin small letter a with acute */ { ISFUNC, rl_insert }, /* Latin small letter a with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter a with tilde */ { ISFUNC, rl_insert }, /* Latin small letter a with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter a with ring above */ { ISFUNC, rl_insert }, /* Latin small letter ae */ { ISFUNC, rl_insert }, /* Latin small letter c with cedilla */ { ISFUNC, rl_insert }, /* Latin small letter e with grave */ { ISFUNC, rl_insert }, /* Latin small letter e with acute */ { ISFUNC, rl_insert }, /* Latin small letter e with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter e with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter i with grave */ { ISFUNC, rl_insert }, /* Latin small letter i with acute */ { ISFUNC, rl_insert }, /* Latin small letter i with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter i with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter eth (Icelandic) */ { ISFUNC, rl_insert }, /* Latin small letter n with tilde */ { ISFUNC, rl_insert }, /* Latin small letter o with grave */ { ISFUNC, rl_insert }, /* Latin small letter o with acute */ { ISFUNC, rl_insert }, /* Latin small letter o with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter o with tilde */ { ISFUNC, rl_insert }, /* Latin small letter o with diaeresis */ { ISFUNC, rl_insert }, /* Division sign */ { ISFUNC, rl_insert }, /* Latin small letter o with stroke */ { ISFUNC, rl_insert }, /* Latin small letter u with grave */ { ISFUNC, rl_insert }, /* Latin small letter u with acute */ { ISFUNC, rl_insert }, /* Latin small letter u with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter u with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter y with acute */ { ISFUNC, rl_insert }, /* Latin small letter thorn (Icelandic) */ { ISFUNC, rl_insert } /* Latin small letter y with diaeresis */ #endif /* KEYMAP_SIZE > 128 */ }; /* Unused for the time being. */ #if 0 KEYMAP_ENTRY_ARRAY vi_escape_keymap = { /* The regular control keys come first. */ { ISFUNC, (Function *)0x0 }, /* Control-@ */ { ISFUNC, (Function *)0x0 }, /* Control-a */ { ISFUNC, (Function *)0x0 }, /* Control-b */ { ISFUNC, (Function *)0x0 }, /* Control-c */ { ISFUNC, (Function *)0x0 }, /* Control-d */ { ISFUNC, (Function *)0x0 }, /* Control-e */ { ISFUNC, (Function *)0x0 }, /* Control-f */ { ISFUNC, (Function *)0x0 }, /* Control-g */ { ISFUNC, (Function *)0x0 }, /* Control-h */ { ISFUNC, rl_tab_insert}, /* Control-i */ { ISFUNC, rl_emacs_editing_mode}, /* Control-j */ { ISFUNC, rl_kill_line }, /* Control-k */ { ISFUNC, (Function *)0x0 }, /* Control-l */ { ISFUNC, rl_emacs_editing_mode}, /* Control-m */ { ISFUNC, (Function *)0x0 }, /* Control-n */ { ISFUNC, (Function *)0x0 }, /* Control-o */ { ISFUNC, (Function *)0x0 }, /* Control-p */ { ISFUNC, (Function *)0x0 }, /* Control-q */ { ISFUNC, (Function *)0x0 }, /* Control-r */ { ISFUNC, (Function *)0x0 }, /* Control-s */ { ISFUNC, (Function *)0x0 }, /* Control-t */ { ISFUNC, (Function *)0x0 }, /* Control-u */ { ISFUNC, (Function *)0x0 }, /* Control-v */ { ISFUNC, (Function *)0x0 }, /* Control-w */ { ISFUNC, (Function *)0x0 }, /* Control-x */ { ISFUNC, (Function *)0x0 }, /* Control-y */ { ISFUNC, (Function *)0x0 }, /* Control-z */ { ISFUNC, rl_vi_movement_mode }, /* Control-[ */ { ISFUNC, (Function *)0x0 }, /* Control-\ */ { ISFUNC, (Function *)0x0 }, /* Control-] */ { ISFUNC, (Function *)0x0 }, /* Control-^ */ { ISFUNC, rl_undo_command }, /* Control-_ */ /* The start of printing characters. */ { ISFUNC, (Function *)0x0 }, /* SPACE */ { ISFUNC, (Function *)0x0 }, /* ! */ { ISFUNC, (Function *)0x0 }, /* " */ { ISFUNC, (Function *)0x0 }, /* # */ { ISFUNC, (Function *)0x0 }, /* $ */ { ISFUNC, (Function *)0x0 }, /* % */ { ISFUNC, (Function *)0x0 }, /* & */ { ISFUNC, (Function *)0x0 }, /* ' */ { ISFUNC, (Function *)0x0 }, /* ( */ { ISFUNC, (Function *)0x0 }, /* ) */ { ISFUNC, (Function *)0x0 }, /* * */ { ISFUNC, (Function *)0x0 }, /* + */ { ISFUNC, (Function *)0x0 }, /* , */ { ISFUNC, (Function *)0x0 }, /* - */ { ISFUNC, (Function *)0x0 }, /* . */ { ISFUNC, (Function *)0x0 }, /* / */ /* Regular digits. */ { ISFUNC, rl_vi_arg_digit }, /* 0 */ { ISFUNC, rl_vi_arg_digit }, /* 1 */ { ISFUNC, rl_vi_arg_digit }, /* 2 */ { ISFUNC, rl_vi_arg_digit }, /* 3 */ { ISFUNC, rl_vi_arg_digit }, /* 4 */ { ISFUNC, rl_vi_arg_digit }, /* 5 */ { ISFUNC, rl_vi_arg_digit }, /* 6 */ { ISFUNC, rl_vi_arg_digit }, /* 7 */ { ISFUNC, rl_vi_arg_digit }, /* 8 */ { ISFUNC, rl_vi_arg_digit }, /* 9 */ /* A little more punctuation. */ { ISFUNC, (Function *)0x0 }, /* : */ { ISFUNC, (Function *)0x0 }, /* ; */ { ISFUNC, (Function *)0x0 }, /* < */ { ISFUNC, (Function *)0x0 }, /* = */ { ISFUNC, (Function *)0x0 }, /* > */ { ISFUNC, (Function *)0x0 }, /* ? */ { ISFUNC, (Function *)0x0 }, /* @ */ /* Uppercase alphabet. */ { ISFUNC, rl_do_lowercase_version }, /* A */ { ISFUNC, rl_do_lowercase_version }, /* B */ { ISFUNC, rl_do_lowercase_version }, /* C */ { ISFUNC, rl_do_lowercase_version }, /* D */ { ISFUNC, rl_do_lowercase_version }, /* E */ { ISFUNC, rl_do_lowercase_version }, /* F */ { ISFUNC, rl_do_lowercase_version }, /* G */ { ISFUNC, rl_do_lowercase_version }, /* H */ { ISFUNC, rl_do_lowercase_version }, /* I */ { ISFUNC, rl_do_lowercase_version }, /* J */ { ISFUNC, rl_do_lowercase_version }, /* K */ { ISFUNC, rl_do_lowercase_version }, /* L */ { ISFUNC, rl_do_lowercase_version }, /* M */ { ISFUNC, rl_do_lowercase_version }, /* N */ { ISFUNC, rl_do_lowercase_version }, /* O */ { ISFUNC, rl_do_lowercase_version }, /* P */ { ISFUNC, rl_do_lowercase_version }, /* Q */ { ISFUNC, rl_do_lowercase_version }, /* R */ { ISFUNC, rl_do_lowercase_version }, /* S */ { ISFUNC, rl_do_lowercase_version }, /* T */ { ISFUNC, rl_do_lowercase_version }, /* U */ { ISFUNC, rl_do_lowercase_version }, /* V */ { ISFUNC, rl_do_lowercase_version }, /* W */ { ISFUNC, rl_do_lowercase_version }, /* X */ { ISFUNC, rl_do_lowercase_version }, /* Y */ { ISFUNC, rl_do_lowercase_version }, /* Z */ /* Some more punctuation. */ { ISFUNC, rl_arrow_keys }, /* [ */ { ISFUNC, (Function *)0x0 }, /* \ */ { ISFUNC, (Function *)0x0 }, /* ] */ { ISFUNC, (Function *)0x0 }, /* ^ */ { ISFUNC, (Function *)0x0 }, /* _ */ { ISFUNC, (Function *)0x0 }, /* ` */ /* Lowercase alphabet. */ { ISFUNC, (Function *)0x0 }, /* a */ { ISFUNC, (Function *)0x0 }, /* b */ { ISFUNC, (Function *)0x0 }, /* c */ { ISFUNC, (Function *)0x0 }, /* d */ { ISFUNC, (Function *)0x0 }, /* e */ { ISFUNC, (Function *)0x0 }, /* f */ { ISFUNC, (Function *)0x0 }, /* g */ { ISFUNC, (Function *)0x0 }, /* h */ { ISFUNC, (Function *)0x0 }, /* i */ { ISFUNC, (Function *)0x0 }, /* j */ { ISFUNC, (Function *)0x0 }, /* k */ { ISFUNC, (Function *)0x0 }, /* l */ { ISFUNC, (Function *)0x0 }, /* m */ { ISFUNC, (Function *)0x0 }, /* n */ { ISFUNC, rl_arrow_keys }, /* o */ { ISFUNC, (Function *)0x0 }, /* p */ { ISFUNC, (Function *)0x0 }, /* q */ { ISFUNC, (Function *)0x0 }, /* r */ { ISFUNC, (Function *)0x0 }, /* s */ { ISFUNC, (Function *)0x0 }, /* t */ { ISFUNC, (Function *)0x0 }, /* u */ { ISFUNC, (Function *)0x0 }, /* v */ { ISFUNC, (Function *)0x0 }, /* w */ { ISFUNC, (Function *)0x0 }, /* x */ { ISFUNC, (Function *)0x0 }, /* y */ { ISFUNC, (Function *)0x0 }, /* z */ /* Final punctuation. */ { ISFUNC, (Function *)0x0 }, /* { */ { ISFUNC, (Function *)0x0 }, /* | */ { ISFUNC, (Function *)0x0 }, /* } */ { ISFUNC, (Function *)0x0 }, /* ~ */ { ISFUNC, rl_backward_kill_word }, /* RUBOUT */ #if KEYMAP_SIZE > 128 /* Undefined keys. */ { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 } #endif /* KEYMAP_SIZE > 128 */ }; #endif lafe/readline/COPYING100644 325 24 31201 6106101041 12537 0ustar dlduser GNU GENERAL PUBLIC LICENSE Version 1, February 1989 Copyright (C) 1989 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. The Free Software Foundation has exempted Bash from the requirement of Paragraph 2c of the General Public License. This is to say, there is no requirement for Bash to print a notice when it is started interactively in the usual way. We made this exception because users and standards expect shells not to print such messages. This exception applies to any program that serves as a shell and that is based primarily on Bash as opposed to other GNU software. Preamble The license agreements of most software companies try to keep users at the mercy of those companies. By contrast, our General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. The General Public License applies to the Free Software Foundation's software and to any other program whose authors commit to using it. You can use it for your programs, too. When we speak of free software, we are referring to freedom, not price. Specifically, the General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of a such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any work containing the Program or a portion of it, either verbatim or with modifications. Each licensee is addressed as "you". 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this General Public License and to the absence of any warranty; and give any other recipients of the Program a copy of this General Public License along with the Program. You may charge a fee for the physical act of transferring a copy. 2. You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following: a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and b) cause the whole of any work that you distribute or publish, that in whole or in part contains the Program or any part thereof, either with or without modifications, to be licensed at no charge to all third parties under the terms of this General Public License (except that you may choose to grant warranty protection to some or all third parties, at your option). c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the simplest and most usual way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this General Public License. d) You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms. 3. You may copy and distribute the Program (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following: a) accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or, b) accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal charge for the cost of distribution) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or, c) accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.) Source code for a work means the preferred form of the work for making modifications to it. For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs, or for standard header files or definitions files that accompany that operating system. 4. You may not copy, modify, sublicense, distribute or transfer the Program except as expressly provided under this General Public License. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the Program is void, and will automatically terminate your rights to use the Program under this License. However, parties who have received copies, or rights to use copies, from you under this General Public License will not have their licenses terminated so long as such parties remain in full compliance. 5. By copying, distributing or modifying the Program (or any work based on the Program) you indicate your acceptance of this license to do so, and all its terms and conditions. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. 7. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of the license which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the license, you may choose any version ever published by the Free Software Foundation. 8. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to humanity, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19xx name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (a program to direct compilers to make passes at assemblers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice That's all there is to it! lafe/readline/ansi_stdlib.h100644 325 24 2450 6106101041 14134 0ustar dlduser/* ansi_stdlib.h -- An ANSI Standard stdlib.h. */ /* A minimal stdlib.h containing extern declarations for those functions that bash uses. */ /* Copyright (C) 1993 Free Software Foundation, Inc. This file is part of GNU Bash, the Bourne Again SHell. Bash is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. Bash is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Bash; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (_STDLIB_H_) #define _STDLIB_H_ 1 /* String conversion functions. */ extern int atoi (); extern long int atol (); /* Memory allocation functions. */ extern char *malloc (); extern char *realloc (); extern void free (); /* Other miscellaneous functions. */ extern void abort (); extern void exit (); extern char *getenv (); extern void qsort (); #endif /* _STDLIB_H */ lafe/readline/Makefile.in100644 325 24 13562 6106101041 13563 0ustar dlduser# Master Makefile for the GNU readline library. # Copyright (C) 1994 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. srcdir = @srcdir@ VPATH = @srcdir@ prefix = /usr/local exec_prefix = $(prefix) bindir = $(exec_prefix)/bin libdir = $(exec_prefix)/lib mandir = $(prefix)/man/man1 SHELL = /bin/sh INSTALL = @INSTALL@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ RANLIB = @RANLIB@ AR = ar RM = rm CP = cp MV = mv DEFS = @DEFS@ CFLAGS = @CFLAGS@ LDFLAGS = @LDFLAGS@ # For libraries which include headers from other libraries. INCLUDES = -I. -I$(srcdir) CPPFLAGS = $(DEFS) $(INCLUDES) PICFLAG= -pic # -fpic for some versions of gcc SHLIB_OPTS= -assert pure-text -ldl # -Bshareable for some versions of gcc MAJOR= 2 MINOR= .0 .SUFFIXES: .so .c.o: $(CC) -c $(CPPFLAGS) $(CFLAGS) $< .c.so: -mv $*.o z$*.o $(CC) -c $(PICFLAG) $(CPPFLAGS) $(CFLAGS) $< mv $*.o $@ -mv z$*.o $*.o # The name of the main library target. LIBRARY_NAME = libreadline.a SHARED_READLINE = libreadline.so.$(MAJOR)$(MINOR) SHARED_HISTORY = libhistory.so.$(MAJOR)$(MINOR) SHARED_LIBS = $(SHARED_READLINE) $(SHARED_HISTORY) # The C code source files for this library. CSOURCES = $(srcdir)readline.c $(srcdir)funmap.c $(srcdir)keymaps.c \ $(srcdir)vi_mode.c $(srcdir)parens.c $(srcdir)rltty.c \ $(srcdir)complete.c $(srcdir)bind.c $(srcdir)isearch.c \ $(srcdir)display.c $(srcdir)signals.c $(srcdir)emacs_keymap.c \ $(srcdir)vi_keymap.c $(srcdir)history.c $(srcdir)tilde.c \ $(srcdir)xmalloc.c # The header files for this library. HSOURCES = readline.h rldefs.h chardefs.h keymaps.h history.h \ posixstat.h tilde.h rlconf.h INSTALLED_HEADERS = readline.h chardefs.h keymaps.h history.h OBJECTS = readline.o vi_mode.o funmap.o keymaps.o parens.o search.o \ rltty.o complete.o bind.o isearch.o display.o signals.o \ history.o tilde.o xmalloc.o SHARED_OBJ = readline.so vi_mode.so funmap.so keymaps.so parens.so search.so \ rltty.so complete.so bind.so isearch.so display.so signals.so \ history.so tilde.so xmalloc.so # The texinfo files which document this library. DOCSOURCE = doc/rlman.texinfo doc/rltech.texinfo doc/rluser.texinfo DOCOBJECT = doc/readline.dvi DOCSUPPORT = doc/Makefile DOCUMENTATION = $(DOCSOURCE) $(DOCOBJECT) $(DOCSUPPORT) SUPPORT = Makefile ChangeLog $(DOCSUPPORT) examples/[-a-z.]* SOURCES = $(CSOURCES) $(HSOURCES) $(DOCSOURCE) THINGS_TO_TAR = $(SOURCES) $(SUPPORT) ########################################################################## all: libreadline.a libhistory.a shared: $(SHARED_LIBS) libreadline.a: $(OBJECTS) $(RM) -f $@ $(AR) cq $@ $(OBJECTS) -$(RANLIB) $@ libhistory.a: history.o $(RM) -f $@ $(AR) cq $@ history.o -$(RANLIB) $@ $(SHARED_READLINE): $(SHARED_OBJ) $(RM) -f $@ ld ${SHLIB_OPTS} -o $@ $(SHARED_OBJ) $(SHARED_HISTORY): history.so $(RM) -f $@ ld ${SHLIB_OPTS} -o $@ history.so documentation: force [ ! -d doc ] && mkdir doc (if [ -d doc ]; then cd doc; $(MAKE) $(MFLAGS); fi) force: install: installdirs libreadline.a $(INSTALL_DATA) $(INSTALLED_HEADERS) $(incdir)/readline -$(MV) $(libdir)/libreadline.a $(libdir)/libreadline.old $(INSTALL_DATA) libreadline.a $(libdir)/libreadline.a -$(RANLIB) -t $(libdir)/libreadline.a installdirs: [ ! -d $(incdir)/readline ] && { \ mkdir $(incdir)/readline && chmod 755 $(incdir)/readline; } [ ! -d $(libdir) ] && mkdir $(libdir) uninstall: [ -n "$(incdir)" ] && cd $(incdir)/readline && \ ${RM} -f ${INSTALLED_HEADERS} [ -n "$(libdir)" ] && cd $(libdir) && \ ${RM} -f libreadline.a libreadline.old $(SHARED_LIBS) clean:: rm -f $(OBJECTS) *.a $(SHARED_OBJ) $(SHARED_LIBS) (if [ -d doc ]; then cd doc; $(MAKE) $(MFLAGS) $@; fi) readline: readline.h rldefs.h chardefs.h readline: $(OBJECTS) $(CC) $(CFLAGS) $(CPPFLAGS) $(READLINE_DEFINES) \ $(LOCAL_INCLUDES) -DTEST -o readline readline.c vi_mode.o funmap.o \ keymaps.o -ltermcap info: install-info: dvi: check: installcheck: tags: force etags $(CSOURCES) $(HSOURCES) TAGS: force ctags -x $(CSOURCES) $(HSOURCES) > $@ Makefile: config.status $(srcdir)/Makefile.in $(SHELL) config.status config.status: configure $(SHELL) config.status --recheck configure: configure.in ## Comment-me-out in distribution cd $(srcdir); autoconf ## Comment-me-out in distribution config.h.in: configure.in ## Comment-me-out in distribution cd $(srcdir); autoheader ## Comment-me-out in distribution mostlyclean: clean distclean realclean: clean rm -f Makefile config.status config.h stamp-config # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: # Dependencies readline.o: readline.c readline.h rldefs.h rlconf.h chardefs.h readline.o: keymaps.h history.h vi_mode.o: rldefs.h rlconf.h readline.h history.h funmap.o: funmap.c readline.h rlconf.h keymaps.o: keymaps.c emacs_keymap.c vi_keymap.c keymaps.h chardefs.h rlconf.h history.o: history.h memalloc.h isearch.o: memalloc.h readline.h history.h search.o: memalloc.h readline.h history.h display.o: readline.h history.h rldefs.h rlconf.h complete.o: readline.h rldefs.h rlconf.h rltty.o: rldefs.h rlconf.h readline.h bind.o: rldefs.h rlconf.h readline.h history.h signals.o: rldefs.h rlconf.h readline.h history.h parens.o: readline.h lafe/readline/memalloc.h100644 325 24 3205 6106101041 13431 0ustar dlduser/* memalloc.h -- consolidate code for including alloca.h or malloc.h and defining alloca. */ /* Copyright (C) 1993 Free Software Foundation, Inc. This file is part of GNU Bash, the Bourne Again SHell. Bash is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. Bash is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Bash; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (__MEMALLOC_H__) # define __MEMALLOC_H__ #if defined (sparc) && defined (sun) && !defined (HAVE_ALLOCA_H) # define HAVE_ALLOCA_H #endif #if defined (__GNUC__) && !defined (HAVE_ALLOCA) # define HAVE_ALLOCA #endif #if defined (HAVE_ALLOCA_H) && !defined (HAVE_ALLOCA) # define HAVE_ALLOCA #endif /* HAVE_ALLOCA_H && !HAVE_ALLOCA */ #if !defined (BUILDING_MAKEFILE) #if defined (__GNUC__) # undef alloca # define alloca __builtin_alloca #else /* !__GNUC__ */ # if defined (HAVE_ALLOCA_H) # if defined (IBMESA) # include # else /* !IBMESA */ # include # endif /* !IBMESA */ # else extern char *alloca (); # endif /* !HAVE_ALLOCA_H */ #endif /* !__GNUC__ */ #endif /* !BUILDING_MAKEFILE */ #endif /* __MEMALLOC_H__ */ lafe/readline/search.c100644 325 24 21673 6106101041 13131 0ustar dlduser/* search.c - code for non-incremental searching in emacs and vi modes. */ /* Copyright (C) 1992 Free Software Foundation, Inc. This file is part of the Readline Library (the Library), a set of routines for providing Emacs style line input to programs that ask for it. The Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #if defined (HAVE_UNISTD_H) # include #endif #include "memalloc.h" #include "rldefs.h" #include "readline.h" #include "history.h" #define STREQ(a, b) (((a)[0] == (b)[0]) && (strcmp ((a), (b)) == 0)) #define STREQN(a, b, n) (((a)[0] == (b)[0]) && (strncmp ((a), (b), (n)) == 0)) #define abs(x) (((x) > 0) ? (x) : -(x)) extern char *xmalloc (), *xrealloc (); /* Variables imported from readline.c */ extern int rl_point, rl_end, rl_line_buffer_len; extern Keymap _rl_keymap; extern char *rl_prompt; extern char *rl_line_buffer; extern HIST_ENTRY *saved_line_for_history; extern Function *rl_last_func; /* Functions imported from the rest of the library. */ extern int _rl_free_history_entry (); static char *noninc_search_string = (char *) NULL; static int noninc_history_pos = 0; static char *prev_line_found = (char *) NULL; /* Search the history list for STRING starting at absolute history position POS. If STRING begins with `^', the search must match STRING at the beginning of a history line, otherwise a full substring match is performed for STRING. DIR < 0 means to search backwards through the history list, DIR >= 0 means to search forward. */ static int noninc_search_from_pos (string, pos, dir) char *string; int pos, dir; { int ret, old; old = where_history (); history_set_pos (pos); if (*string == '^') ret = history_search_prefix (string + 1, dir); else ret = history_search (string, dir); if (ret != -1) ret = where_history (); history_set_pos (old); return (ret); } /* Search for a line in the history containing STRING. If DIR is < 0, the search is backwards through previous entries, else through subsequent entries. */ static void noninc_dosearch (string, dir) char *string; int dir; { int oldpos, pos; HIST_ENTRY *entry; if (string == 0 || *string == 0 || noninc_history_pos < 0) { ding (); return; } pos = noninc_search_from_pos (string, noninc_history_pos + dir, dir); if (pos == -1) { /* Search failed, current history position unchanged. */ maybe_unsave_line (); rl_clear_message (); rl_point = 0; ding (); return; } noninc_history_pos = pos; oldpos = where_history (); history_set_pos (noninc_history_pos); entry = current_history (); history_set_pos (oldpos); { int line_len; line_len = strlen (entry->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (rl_line_buffer, entry->line); } rl_undo_list = (UNDO_LIST *)entry->data; rl_end = strlen (rl_line_buffer); rl_point = 0; rl_clear_message (); if (saved_line_for_history) _rl_free_history_entry (saved_line_for_history); saved_line_for_history = (HIST_ENTRY *)NULL; } /* Search non-interactively through the history list. DIR < 0 means to search backwards through the history of previous commands; otherwise the search is for commands subsequent to the current position in the history list. PCHAR is the character to use for prompting when reading the search string; if not specified (0), it defaults to `:'. */ static void noninc_search (dir, pchar) int dir; int pchar; { int saved_point, c, pmtlen; char *p; maybe_save_line (); saved_point = rl_point; /* Use the line buffer to read the search string. */ rl_line_buffer[0] = 0; rl_end = rl_point = 0; /* XXX - this needs fixing to work with the prompt expansion stuff - XXX */ pmtlen = (rl_prompt && *rl_prompt) ? strlen (rl_prompt) : 0; p = xmalloc (2 + pmtlen); if (pmtlen) strcpy (p, rl_prompt); p[pmtlen] = pchar ? pchar : ':'; p[pmtlen + 1] = '\0'; rl_message (p, 0, 0); free (p); /* Read the search string. */ while (c = rl_read_key ()) { switch (c) { case CTRL('H'): case RUBOUT: if (rl_point == 0) { maybe_unsave_line (); rl_clear_message (); rl_point = saved_point; return; } rl_rubout (1); break; case CTRL('W'): rl_unix_word_rubout (); break; case CTRL('U'): rl_unix_line_discard (); break; case RETURN: case NEWLINE: goto dosearch; /* NOTREACHED */ break; case CTRL('C'): case CTRL('G'): maybe_unsave_line (); rl_clear_message (); rl_point = saved_point; ding (); return; default: rl_insert (1, c); break; } rl_redisplay (); } dosearch: /* If rl_point == 0, we want to re-use the previous search string and start from the saved history position. If there's no previous search string, punt. */ if (rl_point == 0) { if (!noninc_search_string) { ding (); return; } } else { /* We want to start the search from the current history position. */ noninc_history_pos = where_history (); if (noninc_search_string) free (noninc_search_string); noninc_search_string = savestring (rl_line_buffer); } noninc_dosearch (noninc_search_string, dir); } /* Search forward through the history list for a string. If the vi-mode code calls this, KEY will be `?'. */ rl_noninc_forward_search (count, key) int count, key; { if (key == '?') noninc_search (1, '?'); else noninc_search (1, 0); return 0; } /* Reverse search the history list for a string. If the vi-mode code calls this, KEY will be `/'. */ rl_noninc_reverse_search (count, key) int count, key; { if (key == '/') noninc_search (-1, '/'); else noninc_search (-1, 0); return 0; } /* Search forward through the history list for the last string searched for. If there is no saved search string, abort. */ rl_noninc_forward_search_again (count, key) int count, key; { if (!noninc_search_string) { ding (); return (-1); } noninc_dosearch (noninc_search_string, 1); return 0; } /* Reverse search in the history list for the last string searched for. If there is no saved search string, abort. */ rl_noninc_reverse_search_again (count, key) int count, key; { if (!noninc_search_string) { ding (); return (-1); } noninc_dosearch (noninc_search_string, -1); return 0; } static int rl_history_search_internal (count, direction) int count, direction; { HIST_ENTRY *temp, *old_temp; int line_len; maybe_save_line (); temp = old_temp = (HIST_ENTRY *)NULL; while (count) { temp = (direction < 0) ? previous_history () : next_history (); if (!temp) break; if (STREQN (rl_line_buffer, temp->line, rl_point)) { /* Don't find multiple instances of the same line. */ if (prev_line_found && STREQ (prev_line_found, temp->line)) continue; if (direction < 0) old_temp = temp; prev_line_found = temp->line; count--; } } if (!temp) { if (direction < 0 && old_temp) temp = old_temp; else { maybe_unsave_line (); ding (); return 1; } } line_len = strlen (temp->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (rl_line_buffer, temp->line); rl_undo_list = (UNDO_LIST *)temp->data; rl_end = line_len; return 0; } /* Search forward in the history for the string of characters from the start of the line to rl_point. This is a non-incremental search. */ int rl_history_search_forward (count, ignore) int count, ignore; { if (count == 0) return (0); if (rl_last_func != rl_history_search_forward) prev_line_found = (char *)NULL; return (rl_history_search_internal (abs (count), (count > 0) ? 1 : -1)); } /* Search backward through the history for the string of characters from the start of the line to rl_point. This is a non-incremental search. */ int rl_history_search_backward (count, ignore) int count, ignore; { if (count == 0) return (0); if (rl_last_func != rl_history_search_backward) prev_line_found = (char *)NULL; return (rl_history_search_internal (abs (count), (count > 0) ? -1 : 1)); } lafe/readline/emacs_keymap.c100644 325 24 102453 6106101041 14336 0ustar dlduser/* emacs_keymap.c -- the keymap for emacs_mode in readline (). */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (BUFSIZ) #include #endif /* !BUFSIZ */ #include "readline.h" /* An array of function pointers, one for each possible key. If the type byte is ISKMAP, then the pointer is the address of a keymap. */ KEYMAP_ENTRY_ARRAY emacs_standard_keymap = { /* Control keys. */ { ISFUNC, (Function *)0x0 }, /* Control-@ */ { ISFUNC, rl_beg_of_line }, /* Control-a */ { ISFUNC, rl_backward }, /* Control-b */ { ISFUNC, (Function *)0x0 }, /* Control-c */ { ISFUNC, rl_delete }, /* Control-d */ { ISFUNC, rl_end_of_line }, /* Control-e */ { ISFUNC, rl_forward }, /* Control-f */ { ISFUNC, rl_abort }, /* Control-g */ { ISFUNC, rl_rubout }, /* Control-h */ { ISFUNC, rl_complete }, /* Control-i */ { ISFUNC, rl_newline }, /* Control-j */ { ISFUNC, rl_kill_line }, /* Control-k */ { ISFUNC, rl_clear_screen }, /* Control-l */ { ISFUNC, rl_newline }, /* Control-m */ { ISFUNC, rl_get_next_history }, /* Control-n */ { ISFUNC, (Function *)0x0 }, /* Control-o */ { ISFUNC, rl_get_previous_history }, /* Control-p */ { ISFUNC, rl_quoted_insert }, /* Control-q */ { ISFUNC, rl_reverse_search_history }, /* Control-r */ { ISFUNC, rl_forward_search_history }, /* Control-s */ { ISFUNC, rl_transpose_chars }, /* Control-t */ { ISFUNC, rl_unix_line_discard }, /* Control-u */ { ISFUNC, rl_quoted_insert }, /* Control-v */ { ISFUNC, rl_unix_word_rubout }, /* Control-w */ { ISKMAP, (Function *)emacs_ctlx_keymap }, /* Control-x */ { ISFUNC, rl_yank }, /* Control-y */ { ISFUNC, (Function *)0x0 }, /* Control-z */ { ISKMAP, (Function *)emacs_meta_keymap }, /* Control-[ */ { ISFUNC, (Function *)0x0 }, /* Control-\ */ { ISFUNC, (Function *)0x0 }, /* Control-] */ { ISFUNC, (Function *)0x0 }, /* Control-^ */ { ISFUNC, rl_undo_command }, /* Control-_ */ /* The start of printing characters. */ { ISFUNC, rl_insert }, /* SPACE */ { ISFUNC, rl_insert }, /* ! */ { ISFUNC, rl_insert }, /* " */ { ISFUNC, rl_insert }, /* # */ { ISFUNC, rl_insert }, /* $ */ { ISFUNC, rl_insert }, /* % */ { ISFUNC, rl_insert }, /* & */ { ISFUNC, rl_insert }, /* ' */ { ISFUNC, rl_insert }, /* ( */ #if defined (PAREN_MATCHING) { ISFUNC, rl_insert_close }, /* ) */ #else { ISFUNC, rl_insert }, /* ) */ #endif /* !PAREN_MATCHING */ { ISFUNC, rl_insert }, /* * */ { ISFUNC, rl_insert }, /* + */ { ISFUNC, rl_insert }, /* , */ { ISFUNC, rl_insert }, /* - */ { ISFUNC, rl_insert }, /* . */ { ISFUNC, rl_insert }, /* / */ /* Regular digits. */ { ISFUNC, rl_insert }, /* 0 */ { ISFUNC, rl_insert }, /* 1 */ { ISFUNC, rl_insert }, /* 2 */ { ISFUNC, rl_insert }, /* 3 */ { ISFUNC, rl_insert }, /* 4 */ { ISFUNC, rl_insert }, /* 5 */ { ISFUNC, rl_insert }, /* 6 */ { ISFUNC, rl_insert }, /* 7 */ { ISFUNC, rl_insert }, /* 8 */ { ISFUNC, rl_insert }, /* 9 */ /* A little more punctuation. */ { ISFUNC, rl_insert }, /* : */ { ISFUNC, rl_insert }, /* ; */ { ISFUNC, rl_insert }, /* < */ { ISFUNC, rl_insert }, /* = */ { ISFUNC, rl_insert }, /* > */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* @ */ /* Uppercase alphabet. */ { ISFUNC, rl_insert }, /* A */ { ISFUNC, rl_insert }, /* B */ { ISFUNC, rl_insert }, /* C */ { ISFUNC, rl_insert }, /* D */ { ISFUNC, rl_insert }, /* E */ { ISFUNC, rl_insert }, /* F */ { ISFUNC, rl_insert }, /* G */ { ISFUNC, rl_insert }, /* H */ { ISFUNC, rl_insert }, /* I */ { ISFUNC, rl_insert }, /* J */ { ISFUNC, rl_insert }, /* K */ { ISFUNC, rl_insert }, /* L */ { ISFUNC, rl_insert }, /* M */ { ISFUNC, rl_insert }, /* N */ { ISFUNC, rl_insert }, /* O */ { ISFUNC, rl_insert }, /* P */ { ISFUNC, rl_insert }, /* Q */ { ISFUNC, rl_insert }, /* R */ { ISFUNC, rl_insert }, /* S */ { ISFUNC, rl_insert }, /* T */ { ISFUNC, rl_insert }, /* U */ { ISFUNC, rl_insert }, /* V */ { ISFUNC, rl_insert }, /* W */ { ISFUNC, rl_insert }, /* X */ { ISFUNC, rl_insert }, /* Y */ { ISFUNC, rl_insert }, /* Z */ /* Some more punctuation. */ { ISFUNC, rl_insert }, /* [ */ { ISFUNC, rl_insert }, /* \ */ #if defined (PAREN_MATCHING) { ISFUNC, rl_insert_close }, /* ] */ #else { ISFUNC, rl_insert }, /* ] */ #endif /* !PAREN_MATCHING */ { ISFUNC, rl_insert }, /* ^ */ { ISFUNC, rl_insert }, /* _ */ { ISFUNC, rl_insert }, /* ` */ /* Lowercase alphabet. */ { ISFUNC, rl_insert }, /* a */ { ISFUNC, rl_insert }, /* b */ { ISFUNC, rl_insert }, /* c */ { ISFUNC, rl_insert }, /* d */ { ISFUNC, rl_insert }, /* e */ { ISFUNC, rl_insert }, /* f */ { ISFUNC, rl_insert }, /* g */ { ISFUNC, rl_insert }, /* h */ { ISFUNC, rl_insert }, /* i */ { ISFUNC, rl_insert }, /* j */ { ISFUNC, rl_insert }, /* k */ { ISFUNC, rl_insert }, /* l */ { ISFUNC, rl_insert }, /* m */ { ISFUNC, rl_insert }, /* n */ { ISFUNC, rl_insert }, /* o */ { ISFUNC, rl_insert }, /* p */ { ISFUNC, rl_insert }, /* q */ { ISFUNC, rl_insert }, /* r */ { ISFUNC, rl_insert }, /* s */ { ISFUNC, rl_insert }, /* t */ { ISFUNC, rl_insert }, /* u */ { ISFUNC, rl_insert }, /* v */ { ISFUNC, rl_insert }, /* w */ { ISFUNC, rl_insert }, /* x */ { ISFUNC, rl_insert }, /* y */ { ISFUNC, rl_insert }, /* z */ /* Final punctuation. */ { ISFUNC, rl_insert }, /* { */ { ISFUNC, rl_insert }, /* | */ #if defined (PAREN_MATCHING) { ISFUNC, rl_insert_close }, /* } */ #else { ISFUNC, rl_insert }, /* } */ #endif /* !PAREN_MATCHING */ { ISFUNC, rl_insert }, /* ~ */ { ISFUNC, rl_rubout }, /* RUBOUT */ #if KEYMAP_SIZE > 128 /* Pure 8-bit characters (128 - 159). These might be used in some character sets. */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ { ISFUNC, rl_insert }, /* ? */ /* ISO Latin-1 characters (160 - 255) */ { ISFUNC, rl_insert }, /* No-break space */ { ISFUNC, rl_insert }, /* Inverted exclamation mark */ { ISFUNC, rl_insert }, /* Cent sign */ { ISFUNC, rl_insert }, /* Pound sign */ { ISFUNC, rl_insert }, /* Currency sign */ { ISFUNC, rl_insert }, /* Yen sign */ { ISFUNC, rl_insert }, /* Broken bar */ { ISFUNC, rl_insert }, /* Section sign */ { ISFUNC, rl_insert }, /* Diaeresis */ { ISFUNC, rl_insert }, /* Copyright sign */ { ISFUNC, rl_insert }, /* Feminine ordinal indicator */ { ISFUNC, rl_insert }, /* Left pointing double angle quotation mark */ { ISFUNC, rl_insert }, /* Not sign */ { ISFUNC, rl_insert }, /* Soft hyphen */ { ISFUNC, rl_insert }, /* Registered sign */ { ISFUNC, rl_insert }, /* Macron */ { ISFUNC, rl_insert }, /* Degree sign */ { ISFUNC, rl_insert }, /* Plus-minus sign */ { ISFUNC, rl_insert }, /* Superscript two */ { ISFUNC, rl_insert }, /* Superscript three */ { ISFUNC, rl_insert }, /* Acute accent */ { ISFUNC, rl_insert }, /* Micro sign */ { ISFUNC, rl_insert }, /* Pilcrow sign */ { ISFUNC, rl_insert }, /* Middle dot */ { ISFUNC, rl_insert }, /* Cedilla */ { ISFUNC, rl_insert }, /* Superscript one */ { ISFUNC, rl_insert }, /* Masculine ordinal indicator */ { ISFUNC, rl_insert }, /* Right pointing double angle quotation mark */ { ISFUNC, rl_insert }, /* Vulgar fraction one quarter */ { ISFUNC, rl_insert }, /* Vulgar fraction one half */ { ISFUNC, rl_insert }, /* Vulgar fraction three quarters */ { ISFUNC, rl_insert }, /* Inverted questionk mark */ { ISFUNC, rl_insert }, /* Latin capital letter a with grave */ { ISFUNC, rl_insert }, /* Latin capital letter a with acute */ { ISFUNC, rl_insert }, /* Latin capital letter a with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter a with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter a with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter a with ring above */ { ISFUNC, rl_insert }, /* Latin capital letter ae */ { ISFUNC, rl_insert }, /* Latin capital letter c with cedilla */ { ISFUNC, rl_insert }, /* Latin capital letter e with grave */ { ISFUNC, rl_insert }, /* Latin capital letter e with acute */ { ISFUNC, rl_insert }, /* Latin capital letter e with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter e with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter i with grave */ { ISFUNC, rl_insert }, /* Latin capital letter i with acute */ { ISFUNC, rl_insert }, /* Latin capital letter i with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter i with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter eth (Icelandic) */ { ISFUNC, rl_insert }, /* Latin capital letter n with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter o with grave */ { ISFUNC, rl_insert }, /* Latin capital letter o with acute */ { ISFUNC, rl_insert }, /* Latin capital letter o with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter o with tilde */ { ISFUNC, rl_insert }, /* Latin capital letter o with diaeresis */ { ISFUNC, rl_insert }, /* Multiplication sign */ { ISFUNC, rl_insert }, /* Latin capital letter o with stroke */ { ISFUNC, rl_insert }, /* Latin capital letter u with grave */ { ISFUNC, rl_insert }, /* Latin capital letter u with acute */ { ISFUNC, rl_insert }, /* Latin capital letter u with circumflex */ { ISFUNC, rl_insert }, /* Latin capital letter u with diaeresis */ { ISFUNC, rl_insert }, /* Latin capital letter Y with acute */ { ISFUNC, rl_insert }, /* Latin capital letter thorn (Icelandic) */ { ISFUNC, rl_insert }, /* Latin small letter sharp s (German) */ { ISFUNC, rl_insert }, /* Latin small letter a with grave */ { ISFUNC, rl_insert }, /* Latin small letter a with acute */ { ISFUNC, rl_insert }, /* Latin small letter a with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter a with tilde */ { ISFUNC, rl_insert }, /* Latin small letter a with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter a with ring above */ { ISFUNC, rl_insert }, /* Latin small letter ae */ { ISFUNC, rl_insert }, /* Latin small letter c with cedilla */ { ISFUNC, rl_insert }, /* Latin small letter e with grave */ { ISFUNC, rl_insert }, /* Latin small letter e with acute */ { ISFUNC, rl_insert }, /* Latin small letter e with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter e with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter i with grave */ { ISFUNC, rl_insert }, /* Latin small letter i with acute */ { ISFUNC, rl_insert }, /* Latin small letter i with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter i with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter eth (Icelandic) */ { ISFUNC, rl_insert }, /* Latin small letter n with tilde */ { ISFUNC, rl_insert }, /* Latin small letter o with grave */ { ISFUNC, rl_insert }, /* Latin small letter o with acute */ { ISFUNC, rl_insert }, /* Latin small letter o with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter o with tilde */ { ISFUNC, rl_insert }, /* Latin small letter o with diaeresis */ { ISFUNC, rl_insert }, /* Division sign */ { ISFUNC, rl_insert }, /* Latin small letter o with stroke */ { ISFUNC, rl_insert }, /* Latin small letter u with grave */ { ISFUNC, rl_insert }, /* Latin small letter u with acute */ { ISFUNC, rl_insert }, /* Latin small letter u with circumflex */ { ISFUNC, rl_insert }, /* Latin small letter u with diaeresis */ { ISFUNC, rl_insert }, /* Latin small letter y with acute */ { ISFUNC, rl_insert }, /* Latin small letter thorn (Icelandic) */ { ISFUNC, rl_insert } /* Latin small letter y with diaeresis */ #endif /* KEYMAP_SIZE > 128 */ }; KEYMAP_ENTRY_ARRAY emacs_meta_keymap = { /* Meta keys. Just like above, but the high bit is set. */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-@ */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-a */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-b */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-c */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-d */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-e */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-f */ { ISFUNC, rl_abort }, /* Meta-Control-g */ { ISFUNC, rl_backward_kill_word }, /* Meta-Control-h */ { ISFUNC, rl_tab_insert }, /* Meta-Control-i */ { ISFUNC, rl_vi_editing_mode }, /* Meta-Control-j */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-k */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-l */ { ISFUNC, rl_vi_editing_mode }, /* Meta-Control-m */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-n */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-o */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-p */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-q */ { ISFUNC, rl_revert_line }, /* Meta-Control-r */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-s */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-t */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-u */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-v */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-w */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-x */ { ISFUNC, rl_yank_nth_arg }, /* Meta-Control-y */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-z */ { ISFUNC, rl_complete }, /* Meta-Control-[ */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-\ */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-] */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-^ */ { ISFUNC, (Function *)0x0 }, /* Meta-Control-_ */ /* The start of printing characters. */ { ISFUNC, (Function *)0x0 }, /* Meta-SPACE */ { ISFUNC, (Function *)0x0 }, /* Meta-! */ { ISFUNC, (Function *)0x0 }, /* Meta-" */ { ISFUNC, (Function *)0x0 }, /* Meta-# */ { ISFUNC, (Function *)0x0 }, /* Meta-$ */ { ISFUNC, (Function *)0x0 }, /* Meta-% */ { ISFUNC, rl_tilde_expand }, /* Meta-& */ { ISFUNC, (Function *)0x0 }, /* Meta-' */ { ISFUNC, (Function *)0x0 }, /* Meta-( */ { ISFUNC, (Function *)0x0 }, /* Meta-) */ { ISFUNC, (Function *)0x0 }, /* Meta-* */ { ISFUNC, (Function *)0x0 }, /* Meta-+ */ { ISFUNC, (Function *)0x0 }, /* Meta-, */ { ISFUNC, rl_digit_argument }, /* Meta-- */ { ISFUNC, rl_yank_last_arg}, /* Meta-. */ { ISFUNC, (Function *)0x0 }, /* Meta-/ */ /* Regular digits. */ { ISFUNC, rl_digit_argument }, /* Meta-0 */ { ISFUNC, rl_digit_argument }, /* Meta-1 */ { ISFUNC, rl_digit_argument }, /* Meta-2 */ { ISFUNC, rl_digit_argument }, /* Meta-3 */ { ISFUNC, rl_digit_argument }, /* Meta-4 */ { ISFUNC, rl_digit_argument }, /* Meta-5 */ { ISFUNC, rl_digit_argument }, /* Meta-6 */ { ISFUNC, rl_digit_argument }, /* Meta-7 */ { ISFUNC, rl_digit_argument }, /* Meta-8 */ { ISFUNC, rl_digit_argument }, /* Meta-9 */ /* A little more punctuation. */ { ISFUNC, (Function *)0x0 }, /* Meta-: */ { ISFUNC, (Function *)0x0 }, /* Meta-; */ { ISFUNC, rl_beginning_of_history }, /* Meta-< */ { ISFUNC, (Function *)0x0 }, /* Meta-= */ { ISFUNC, rl_end_of_history }, /* Meta-> */ { ISFUNC, rl_possible_completions }, /* Meta-? */ { ISFUNC, (Function *)0x0 }, /* Meta-@ */ /* Uppercase alphabet. */ { ISFUNC, rl_do_lowercase_version }, /* Meta-A */ { ISFUNC, rl_do_lowercase_version }, /* Meta-B */ { ISFUNC, rl_do_lowercase_version }, /* Meta-C */ { ISFUNC, rl_do_lowercase_version }, /* Meta-D */ { ISFUNC, rl_do_lowercase_version }, /* Meta-E */ { ISFUNC, rl_do_lowercase_version }, /* Meta-F */ { ISFUNC, rl_do_lowercase_version }, /* Meta-G */ { ISFUNC, rl_do_lowercase_version }, /* Meta-H */ { ISFUNC, rl_do_lowercase_version }, /* Meta-I */ { ISFUNC, rl_do_lowercase_version }, /* Meta-J */ { ISFUNC, rl_do_lowercase_version }, /* Meta-K */ { ISFUNC, rl_do_lowercase_version }, /* Meta-L */ { ISFUNC, rl_do_lowercase_version }, /* Meta-M */ { ISFUNC, rl_do_lowercase_version }, /* Meta-N */ { ISFUNC, rl_do_lowercase_version }, /* Meta-O */ { ISFUNC, rl_do_lowercase_version }, /* Meta-P */ { ISFUNC, rl_do_lowercase_version }, /* Meta-Q */ { ISFUNC, rl_do_lowercase_version }, /* Meta-R */ { ISFUNC, rl_do_lowercase_version }, /* Meta-S */ { ISFUNC, rl_do_lowercase_version }, /* Meta-T */ { ISFUNC, rl_do_lowercase_version }, /* Meta-U */ { ISFUNC, rl_do_lowercase_version }, /* Meta-V */ { ISFUNC, rl_do_lowercase_version }, /* Meta-W */ { ISFUNC, rl_do_lowercase_version }, /* Meta-X */ { ISFUNC, rl_do_lowercase_version }, /* Meta-Y */ { ISFUNC, rl_do_lowercase_version }, /* Meta-Z */ /* Some more punctuation. */ { ISFUNC, (Function *)0x0 }, /* Meta-[ */ /* was rl_arrow_keys */ { ISFUNC, rl_delete_horizontal_space }, /* Meta-\ */ { ISFUNC, (Function *)0x0 }, /* Meta-] */ { ISFUNC, (Function *)0x0 }, /* Meta-^ */ { ISFUNC, rl_yank_last_arg }, /* Meta-_ */ { ISFUNC, (Function *)0x0 }, /* Meta-` */ /* Lowercase alphabet. */ { ISFUNC, (Function *)0x0 }, /* Meta-a */ { ISFUNC, rl_backward_word }, /* Meta-b */ { ISFUNC, rl_capitalize_word }, /* Meta-c */ { ISFUNC, rl_kill_word }, /* Meta-d */ { ISFUNC, (Function *)0x0 }, /* Meta-e */ { ISFUNC, rl_forward_word }, /* Meta-f */ { ISFUNC, (Function *)0x0 }, /* Meta-g */ { ISFUNC, (Function *)0x0 }, /* Meta-h */ { ISFUNC, (Function *)0x0 }, /* Meta-i */ { ISFUNC, (Function *)0x0 }, /* Meta-j */ { ISFUNC, (Function *)0x0 }, /* Meta-k */ { ISFUNC, rl_downcase_word }, /* Meta-l */ { ISFUNC, (Function *)0x0 }, /* Meta-m */ { ISFUNC, rl_noninc_forward_search }, /* Meta-n */ { ISFUNC, (Function *)0x0 }, /* Meta-o */ /* was rl_arrow_keys */ { ISFUNC, rl_noninc_reverse_search }, /* Meta-p */ { ISFUNC, (Function *)0x0 }, /* Meta-q */ { ISFUNC, rl_revert_line }, /* Meta-r */ { ISFUNC, (Function *)0x0 }, /* Meta-s */ { ISFUNC, rl_transpose_words }, /* Meta-t */ { ISFUNC, rl_upcase_word }, /* Meta-u */ { ISFUNC, (Function *)0x0 }, /* Meta-v */ { ISFUNC, (Function *)0x0 }, /* Meta-w */ { ISFUNC, (Function *)0x0 }, /* Meta-x */ { ISFUNC, rl_yank_pop }, /* Meta-y */ { ISFUNC, (Function *)0x0 }, /* Meta-z */ /* Final punctuation. */ { ISFUNC, (Function *)0x0 }, /* Meta-{ */ { ISFUNC, (Function *)0x0 }, /* Meta-| */ { ISFUNC, (Function *)0x0 }, /* Meta-} */ { ISFUNC, rl_tilde_expand }, /* Meta-~ */ { ISFUNC, rl_backward_kill_word }, /* Meta-rubout */ #if KEYMAP_SIZE > 128 /* Undefined keys. */ { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 } #endif /* KEYMAP_SIZE > 128 */ }; KEYMAP_ENTRY_ARRAY emacs_ctlx_keymap = { /* Control keys. */ { ISFUNC, (Function *)0x0 }, /* Control-@ */ { ISFUNC, (Function *)0x0 }, /* Control-a */ { ISFUNC, (Function *)0x0 }, /* Control-b */ { ISFUNC, (Function *)0x0 }, /* Control-c */ { ISFUNC, (Function *)0x0 }, /* Control-d */ { ISFUNC, (Function *)0x0 }, /* Control-e */ { ISFUNC, (Function *)0x0 }, /* Control-f */ { ISFUNC, rl_abort }, /* Control-g */ { ISFUNC, (Function *)0x0 }, /* Control-h */ { ISFUNC, (Function *)0x0 }, /* Control-i */ { ISFUNC, (Function *)0x0 }, /* Control-j */ { ISFUNC, (Function *)0x0 }, /* Control-k */ { ISFUNC, (Function *)0x0 }, /* Control-l */ { ISFUNC, (Function *)0x0 }, /* Control-m */ { ISFUNC, (Function *)0x0 }, /* Control-n */ { ISFUNC, (Function *)0x0 }, /* Control-o */ { ISFUNC, (Function *)0x0 }, /* Control-p */ { ISFUNC, (Function *)0x0 }, /* Control-q */ { ISFUNC, rl_re_read_init_file }, /* Control-r */ { ISFUNC, (Function *)0x0 }, /* Control-s */ { ISFUNC, (Function *)0x0 }, /* Control-t */ { ISFUNC, rl_undo_command }, /* Control-u */ { ISFUNC, (Function *)0x0 }, /* Control-v */ { ISFUNC, (Function *)0x0 }, /* Control-w */ { ISFUNC, (Function *)0x0 }, /* Control-x */ { ISFUNC, (Function *)0x0 }, /* Control-y */ { ISFUNC, (Function *)0x0 }, /* Control-z */ { ISFUNC, (Function *)0x0 }, /* Control-[ */ { ISFUNC, (Function *)0x0 }, /* Control-\ */ { ISFUNC, (Function *)0x0 }, /* Control-] */ { ISFUNC, (Function *)0x0 }, /* Control-^ */ { ISFUNC, (Function *)0x0 }, /* Control-_ */ /* The start of printing characters. */ { ISFUNC, (Function *)0x0 }, /* SPACE */ { ISFUNC, (Function *)0x0 }, /* ! */ { ISFUNC, (Function *)0x0 }, /* " */ { ISFUNC, (Function *)0x0 }, /* # */ { ISFUNC, (Function *)0x0 }, /* $ */ { ISFUNC, (Function *)0x0 }, /* % */ { ISFUNC, (Function *)0x0 }, /* & */ { ISFUNC, (Function *)0x0 }, /* ' */ { ISFUNC, rl_start_kbd_macro }, /* ( */ { ISFUNC, rl_end_kbd_macro }, /* ) */ { ISFUNC, (Function *)0x0 }, /* * */ { ISFUNC, (Function *)0x0 }, /* + */ { ISFUNC, (Function *)0x0 }, /* , */ { ISFUNC, (Function *)0x0 }, /* - */ { ISFUNC, (Function *)0x0 }, /* . */ { ISFUNC, (Function *)0x0 }, /* / */ /* Regular digits. */ { ISFUNC, (Function *)0x0 }, /* 0 */ { ISFUNC, (Function *)0x0 }, /* 1 */ { ISFUNC, (Function *)0x0 }, /* 2 */ { ISFUNC, (Function *)0x0 }, /* 3 */ { ISFUNC, (Function *)0x0 }, /* 4 */ { ISFUNC, (Function *)0x0 }, /* 5 */ { ISFUNC, (Function *)0x0 }, /* 6 */ { ISFUNC, (Function *)0x0 }, /* 7 */ { ISFUNC, (Function *)0x0 }, /* 8 */ { ISFUNC, (Function *)0x0 }, /* 9 */ /* A little more punctuation. */ { ISFUNC, (Function *)0x0 }, /* : */ { ISFUNC, (Function *)0x0 }, /* ; */ { ISFUNC, (Function *)0x0 }, /* < */ { ISFUNC, (Function *)0x0 }, /* = */ { ISFUNC, (Function *)0x0 }, /* > */ { ISFUNC, (Function *)0x0 }, /* ? */ { ISFUNC, (Function *)0x0 }, /* @ */ /* Uppercase alphabet. */ { ISFUNC, rl_do_lowercase_version }, /* A */ { ISFUNC, rl_do_lowercase_version }, /* B */ { ISFUNC, rl_do_lowercase_version }, /* C */ { ISFUNC, rl_do_lowercase_version }, /* D */ { ISFUNC, rl_do_lowercase_version }, /* E */ { ISFUNC, rl_do_lowercase_version }, /* F */ { ISFUNC, rl_do_lowercase_version }, /* G */ { ISFUNC, rl_do_lowercase_version }, /* H */ { ISFUNC, rl_do_lowercase_version }, /* I */ { ISFUNC, rl_do_lowercase_version }, /* J */ { ISFUNC, rl_do_lowercase_version }, /* K */ { ISFUNC, rl_do_lowercase_version }, /* L */ { ISFUNC, rl_do_lowercase_version }, /* M */ { ISFUNC, rl_do_lowercase_version }, /* N */ { ISFUNC, rl_do_lowercase_version }, /* O */ { ISFUNC, rl_do_lowercase_version }, /* P */ { ISFUNC, rl_do_lowercase_version }, /* Q */ { ISFUNC, rl_do_lowercase_version }, /* R */ { ISFUNC, rl_do_lowercase_version }, /* S */ { ISFUNC, rl_do_lowercase_version }, /* T */ { ISFUNC, rl_do_lowercase_version }, /* U */ { ISFUNC, rl_do_lowercase_version }, /* V */ { ISFUNC, rl_do_lowercase_version }, /* W */ { ISFUNC, rl_do_lowercase_version }, /* X */ { ISFUNC, rl_do_lowercase_version }, /* Y */ { ISFUNC, rl_do_lowercase_version }, /* Z */ /* Some more punctuation. */ { ISFUNC, (Function *)0x0 }, /* [ */ { ISFUNC, (Function *)0x0 }, /* \ */ { ISFUNC, (Function *)0x0 }, /* ] */ { ISFUNC, (Function *)0x0 }, /* ^ */ { ISFUNC, (Function *)0x0 }, /* _ */ { ISFUNC, (Function *)0x0 }, /* ` */ /* Lowercase alphabet. */ { ISFUNC, (Function *)0x0 }, /* a */ { ISFUNC, (Function *)0x0 }, /* b */ { ISFUNC, (Function *)0x0 }, /* c */ { ISFUNC, (Function *)0x0 }, /* d */ { ISFUNC, rl_call_last_kbd_macro }, /* e */ { ISFUNC, (Function *)0x0 }, /* f */ { ISFUNC, (Function *)0x0 }, /* g */ { ISFUNC, (Function *)0x0 }, /* h */ { ISFUNC, (Function *)0x0 }, /* i */ { ISFUNC, (Function *)0x0 }, /* j */ { ISFUNC, (Function *)0x0 }, /* k */ { ISFUNC, (Function *)0x0 }, /* l */ { ISFUNC, (Function *)0x0 }, /* m */ { ISFUNC, (Function *)0x0 }, /* n */ { ISFUNC, (Function *)0x0 }, /* o */ { ISFUNC, (Function *)0x0 }, /* p */ { ISFUNC, (Function *)0x0 }, /* q */ { ISFUNC, (Function *)0x0 }, /* r */ { ISFUNC, (Function *)0x0 }, /* s */ { ISFUNC, (Function *)0x0 }, /* t */ { ISFUNC, (Function *)0x0 }, /* u */ { ISFUNC, (Function *)0x0 }, /* v */ { ISFUNC, (Function *)0x0 }, /* w */ { ISFUNC, (Function *)0x0 }, /* x */ { ISFUNC, (Function *)0x0 }, /* y */ { ISFUNC, (Function *)0x0 }, /* z */ /* Final punctuation. */ { ISFUNC, (Function *)0x0 }, /* { */ { ISFUNC, (Function *)0x0 }, /* | */ { ISFUNC, (Function *)0x0 }, /* } */ { ISFUNC, (Function *)0x0 }, /* ~ */ { ISFUNC, rl_backward_kill_line }, /* RUBOUT */ #if KEYMAP_SIZE > 128 /* Undefined keys. */ { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 }, { ISFUNC, (Function *)0x0 } #endif /* KEYMAP_SIZE > 128 */ }; lafe/readline/INSTALL100644 325 24 13655 6106101041 12552 0ustar dlduser This is a generic INSTALL file for utilities distributions. If this package does not come with, e.g., installable documentation or data files, please ignore the references to them below. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation, and creates the Makefile(s) (one in each subdirectory of the source directory). In some packages it creates a C header file containing system-dependent definitions. It also creates a file `config.status' that you can run in the future to recreate the current configuration. To compile this package: 1. Configure the package for your system. Normally, you just `cd' to the directory containing the package's source code and type `./configure'. If you're using `csh' on an old version of System V, you might need to type `sh configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes awhile. While it is running, it prints some messages that tell what it is doing. If you don't want to see any messages, run `configure' with its standard output redirected to `/dev/null'; for example, `./configure >/dev/null'. To compile the package in a different directory from the one containing the source code, you must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If for some reason `configure' is not in the source code directory that you are configuring, then it will report that it can't find the source code. In that case, run `configure' with the option `--srcdir=DIR', where DIR is the directory that contains the source code. By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PATH'. Alternately, you can do so by consistently giving a value for the `prefix' variable when you run `make', e.g., make prefix=/usr/gnu make prefix=/usr/gnu install You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH' or set the `make' variable `exec_prefix' to PATH, the package will use PATH as the prefix for installing programs and libraries. Data files and documentation will still use the regular prefix. Normally, all files are installed using the same prefix. Some packages pay attention to `--with-PACKAGE' options to `configure', where PACKAGE is something like `gnu-as' or `x' (for the X Window System). They may also pay attention to `--enable-FEATURE' options, where FEATURE indicates an optional part of the package. The README should mention any `--with-' and `--enable-' options that the package recognizes. `configure' also recognizes the following options: `--help' Print a summary of the options to `configure', and exit. `--quiet' `--silent' Do not print messages saying which checks are being made. `--verbose' Print the results of the checks. `--version' Print the version of Autoconf used to generate the `configure' script, and exit. `--x-includes=DIR' X include files are in DIR. `--x-libraries=DIR' X library files are in DIR. `configure' also accepts and ignores some other options. On systems that require unusual options for compilation or linking that the package's `configure' script does not know about, you can give `configure' initial values for variables by setting them in the environment. In Bourne-compatible shells, you can do that on the command line like this: CC='gcc -traditional' LIBS=-lposix ./configure On systems that have the `env' program, you can do it like this: env CC='gcc -traditional' LIBS=-lposix ./configure Here are the `make' variables that you might want to override with environment variables when running `configure'. For these variables, any value given in the environment overrides the value that `configure' would choose: - Variable: CC C compiler program. The default is `cc'. - Variable: INSTALL Program to use to install files. The default is `install' if you have it, `cp' otherwise. For these variables, any value given in the environment is added to the value that `configure' chooses: - Variable: DEFS Configuration options, in the form `-Dfoo -Dbar...'. Do not use this variable in packages that create a configuration header file. - Variable: LIBS Libraries to link with, in the form `-lfoo -lbar...'. If you need to do unusual things to compile the package, we encourage you to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the README so we can include them in the next release. 2. Type `make' to compile the package. If you want, you can override the `make' variables CFLAGS and LDFLAGS like this: make CFLAGS=-O2 LDFLAGS=-s 3. If the package comes with self-tests and you want to run them, type `make check'. If you're not sure whether there are any, try it; if `make' responds with something like make: *** No way to make target `check'. Stop. then the package does not come with self-tests. 4. Type `make install' to install programs, data files, and documentation. 5. You can remove the program binaries and object files from the source directory by typing `make clean'. To also remove the Makefile(s), the header file containing system-dependent definitions (if the package uses one), and `config.status' (all the files that `configure' created), type `make distclean'. The file `configure.in' is used to create `configure' by a program called `autoconf'. You only need it if you want to regenerate `configure' using a newer version of `autoconf'. lafe/readline/ChangeLog100644 325 24 34254 6106101041 13271 0ustar dlduserSat Nov 25 07:38:40 1995 Drake Diedrich * chardefs.h, tilde.c: included rldefs.h for string dependency * tilde.c, chardefs.h, configure: Initial revision Sat Nov 25 05:06:46 1995 Drake Diedrich * readline.c: Initial revision Tue Mar 23 14:36:51 1993 Brian Fox (bfox@eos.crseo.ucsb.edu) * readline.c (rl_copy): Changed name to rl_copy_text. Mon Mar 22 19:16:05 1993 Brian Fox (bfox@eos.crseo.ucsb.edu) * dispose_cmd.c, several other files. Declare dispose_xxx () as "void". * builtins/hashcom.h: Make declarations of hashed_filenames be "extern" to keep the SGI compiler happy. * readline.c (rl_initialize_everything): Assign values to out_stream and in_stream immediately, since output_character_function () can be called before readline_internal () is called. Tue Dec 8 09:30:56 1992 Brian Fox (bfox@cubit) * readline.c (rl_init_terminal) Set PC from BC, not from *buffer. Mon Nov 30 09:35:47 1992 Brian Fox (bfox@cubit) * readline.c (invoking_keyseqs_in_map, rl_parse_and_bind) Allow backslash to quote characters, such as backslash, double quote, and space. Backslash quotes all character indiscriminately. * funmap.c (vi_keymap) Fix type in "vi-replace" declaration. Fri Nov 20 10:55:05 1992 Brian Fox (bfox@cubit) * readline.c (init_terminal_io, rl_prep_terminal): FINALLY! Declare and use termcap variable `ospeed' when setting up terminal parameters. Thu Oct 8 08:53:07 1992 Brian J. Fox (bfox@helios) * Makefile, this directory: Include (as links to the canonical sources), tilde.c, tilde.h, posixstat.h and xmalloc.c. Tue Sep 29 13:07:21 1992 Brian J. Fox (bfox@helios) * readline.c (init_terminal_io) Don't set arrow keys if the key sequences that represent them are already set. * readline.c (rl_function_of_keyseq) New function returns the first function (or macro) found while searching a key sequence. Mon Sep 28 00:34:04 1992 Brian J. Fox (bfox@helios) * readline.c (LibraryVersion) New static char * contains current version number. Version is at 2.0. * readline.c (rl_complete_internal): Incorporated clean changes from gilmore (gnu@cygnus.com) to support quoted substrings within completion functions. * readline.c (many locations) Added support for the _GO32_, whatever that is. Patches supplied by Cygnus, typed in by hand, with cleanups. Sun Aug 16 12:46:24 1992 Brian Fox (bfox@cubit) * readline.c (init_terminal_io): Find out the values of the keypad arrows and bind them to appropriate RL functions if present. Mon Aug 10 18:13:24 1992 Brian Fox (bfox@cubit) * history.c (stifle_history): A negative argument to stifle becomes zero. Tue Jul 28 09:28:41 1992 Brian Fox (bfox@cubit) * readline.c (rl_variable_bind): New local structure describes booleans by name and address; code in rl_variable_bind () looks at structure to set simple variables. * parens.c (rl_insert_close): New variable rl_blink_matching_paren is non-zero if we want to blink the matching open when a close is inserted. If FD_SET is defined, rl_blink_matching_paren defaults to 1, else 0. If FD_SET is not defined, and rl_blink_matching_paren is non-zero, the close character(s) are/is simply inserted. Wed Jul 22 20:03:59 1992 Brian Fox (bfox@cubit) * history.c, readline.c, vi_mode.c: Cause the functions strchr () and strrchr () to be used instead of index () and rindex () throughout the source. Mon Jul 13 11:34:07 1992 Brian Fox (bfox@cubit) * readline.c: (rl_variable_bind) New variable "meta-flag" if "on" means force the use of the 8th bit as Meta bit. Internal variable is called meta_flag. Thu Jul 9 10:37:56 1992 Brian Fox (bfox@cubit) * history.c (get_history_event) Change INDEX to LOCAL_INDEX. If compiling for the shell, allow shell metacharacters to separate history tokens as they would for shell tokens. Sat Jul 4 19:29:12 1992 Brian Fox (bfox@cubit) * vi_keymap.c: According to Posix, TAB self-inserts instead of doing completion. * vi_mode.c: (rl_vi_yank_arg) Enter VI insert mode after yanking an arg from the previous line. * search.c: New file takes over vi style searching and implements non-incremental searching the history. Makefile: Add search.c and search.o. funmap.c: Add names for non-incremental-forward-search-history and non-incremental-reverse-search-history. readline.h: Add extern definitions for non-incremental searching. vi_mode.c: Remove old search code; add calls to code in search.c. Fri Jul 3 10:36:33 1992 Brian Fox (bfox@cubit) * readline.c (rl_delete_horizontal_space); New function deletes all whitespace surrounding point. funmap.c: Add "delete-horizontal-space". emacs_keymap.c: Put rl_delete_horizontal_space () on M-\. * readline.c (rl_set_signals, rl_clear_signals); New function rl_set_sighandler () is either defined in a Posix way (if HAVE_POSIX_SIGNALS is defined) or in a BSD way. Function is called from rl_set_signals () and rl_clear_signals (). Fri May 8 12:50:15 1992 Brian Fox (bfox@cubit) * readline.c: (readline_default_bindings) Do comparisons with _POSIX_VDISABLE casted to `unsigned char'. Change tty characters to be unsigned char. Thu Apr 30 12:36:35 1992 Brian Fox (bfox@cubit) * readline.c: (rl_getc) Handle "read would block" error on non-blocking IO streams. * readline.c: (rl_signal_handler): Unblock only the signal that we have caught, not all signals. Sun Feb 23 03:33:09 1992 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: Many functions. Use only the macros META_CHAR and UNMETA to deal with meta characters. Prior to this, we used numeric values and tests. * readline.c (rl_complete_internal) Report exactly the number of possible completions, not the number + 1. * vi_mode.c (rl_do_move) Do not change the cursor position when using `cw' or `cW'. * vi_mode.c (rl_vi_complete) Enter insert mode after completing with `*' or `\'. Fri Feb 21 05:58:18 1992 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (rl_dispatch) Increment rl_key_sequence_length for meta characters that map onto ESC map. Mon Feb 10 01:41:35 1992 Brian Fox (bfox at gnuwest.fsf.org) * history.c (history_do_write) Build a buffer of all of the lines to write and write them in one fell swoop (lower overhead than calling write () for each line). Suggested by Peter Ho. * readline.c: Include hbullx20 as well as hpux for determining USGr3ness. * readline.c (rl_unix_word_rubout) As per the "Now REMEMBER" comment, pass arguments to rl_kill_text () in the correct order to preserve prepending and appending of killed text. * readline.c (rl_search_history) malloc (), realloc (), and free () SEARCH_STRING so that there are no static limits on searching. * vi_mode.c (rl_vi_subst) Don't forget to end the undo group. Fri Jan 31 14:51:02 1992 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (rl_signal_handler): Zero the current history entry's pointer after freeing the undo_list when SIGINT received. Reformat a couple of functions. Sat Jan 25 13:47:35 1992 Brian Fox (bfox at bears) * readline.c (parser_if): free () TNAME after use. Tue Jan 21 01:01:35 1992 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (rl_redisplay) and (rl_character_len): Display Control characters as "^c" and Meta characters as "\234", instead of "C-C" and "M-C". Sun Dec 29 10:59:00 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (init_terminal_io) Default to environment variables LINES and COLUMNS before termcap entry values. If all else fails, then assume 80x24 terminal. Sat Dec 28 16:33:11 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: If this machine is USG and it is hpux, then define USGr3. * history.c: Cosmetic fixes. Thu Nov 21 00:10:12 1991 Brian Fox (bfox at gnuwest.fsf.org) * vi_mode.c: (rl_do_move) Place cursor at end of line, never at next to last character. Thu Nov 14 05:08:01 1991 Brian Fox (bfox at gnuwest.fsf.org) * history.c (get_history_event) Non-anchored searches can have a return index of greater than zero from get_history_event (). Fri Nov 1 07:02:13 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (rl_translate_keyseq) Make C-? translate to RUBOUT unconditionally. Mon Oct 28 11:34:52 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c; Use Posix directory routines and macros. * funmap.c; Add entry for call-last-kbd-macro. * readline.c (rl_prep_term); Use system EOF character on POSIX systems also. Thu Oct 3 16:19:53 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c; Make a distinction between having a TERMIOS tty driver, and having POSIX signal handling. You might one without the other. New defines used HAVE_POSIX_SIGNALS, and TERMIOS_TTY_DRIVER. Tue Jul 30 22:37:26 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: rl_getc () If a call to read () returns without an error, but with zero characters, the file is empty, so return EOF. Thu Jul 11 20:58:38 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: (rl_get_next_history, rl_get_previous_history) Reallocate the buffer space if the line being moved to is longer the the current space allocated. Amazing that no one has found this bug until now. Sun Jul 7 02:37:05 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c:(rl_parse_and_bind) Allow leading whitespace. Make sure TERMIO and TERMIOS systems treat CR and NL disctinctly. Tue Jun 25 04:09:27 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: Rework parsing conditionals to pay attention to the prior states of the conditional stack. This makes $if statements work correctly. Mon Jun 24 20:45:59 1991 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: support for displaying key binding information includes the functions rl_list_funmap_names (), invoking_keyseqs_in_map (), rl_invoking_keyseqs (), rl_dump_functions (), and rl_function_dumper (). funmap.c: support for same includes rl_funmap_names (). readline.c, funmap.c: no longer define STATIC_MALLOC. However, update both version of xrealloc () to handle a null pointer. Thu Apr 25 12:03:49 1991 Brian Fox (bfox at gnuwest.fsf.org) * vi_mode.c (rl_vi_fword, fWord, etc. All functions use the macro `isident()'. Fixed movement bug which prevents continious movement through the text. Fri Jul 27 16:47:01 1990 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (parser_if) Allow "$if term=foo" construct. Wed May 23 16:10:33 1990 Brian Fox (bfox at gnuwest.fsf.org) * readline.c (rl_dispatch) Correctly remember the last command executed. Fixed typo in username_completion_function (). Mon Apr 9 19:55:48 1990 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: username_completion_function (); For text passed in with a leading `~', remember that this could be a filename (after it is completed). Thu Apr 5 13:44:24 1990 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: rl_search_history (): Correctly handle case of an unfound search string, but a graceful exit (as with ESC). * readline.c: rl_restart_output (); The Apollo passes the address of the file descriptor to TIOCSTART, not the descriptor itself. Tue Mar 20 05:38:55 1990 Brian Fox (bfox at gnuwest.fsf.org) * readline.c: rl_complete (); second call in a row causes possible completions to be listed. * readline.c: rl_redisplay (), added prompt_this_line variable which is the first character character following \n in prompt. Sun Mar 11 04:32:03 1990 Brian Fox (bfox at gnuwest.fsf.org) * Signals are now supposedly handled inside of SYSV compilation. Wed Jan 17 19:24:09 1990 Brian Fox (bfox at sbphy.ucsb.edu) * history.c: history_expand (); fixed overwriting memory error, added needed argument to call to get_history_event (). Thu Jan 11 10:54:04 1990 Brian Fox (bfox at sbphy.ucsb.edu) * readline.c: added mark_modified_lines to control the display of an asterisk on modified history lines. Also added a user variable called mark-modified-lines to the `set' command. Thu Jan 4 10:38:05 1990 Brian Fox (bfox at sbphy.ucsb.edu) * readline.c: start_insert (). Only use IC if we don't have an im capability. Fri Sep 8 09:00:45 1989 Brian Fox (bfox at aurel) * readline.c: rl_prep_terminal (). Only turn on 8th bit as meta-bit iff the terminal is not using parity. Sun Sep 3 08:57:40 1989 Brian Fox (bfox at aurel) * readline.c: start_insert (). Uses multiple insertion call in cases where that makes sense. rl_insert (). Read type-ahead buffer for additional keys that are bound to rl_insert, and insert them all at once. Make insertion of single keys given with an argument much more efficient. Tue Aug 8 18:13:57 1989 Brian Fox (bfox at aurel) * readline.c: Changed handling of EOF. readline () returns (char *)EOF or consed string. The EOF character is read from the tty, or if the tty doesn't have one, defaults to C-d. * readline.c: Added support for event driven programs. rl_event_hook is the address of a function you want called while Readline is waiting for input. * readline.c: Cleanup time. Functions without type declarations do not use return with a value. * history.c: history_expand () has new variable which is the characters to ignore immediately following history_expansion_char. Sun Jul 16 08:14:00 1989 Brian Fox (bfox at aurel) * rl_prep_terminal () BSD version turns off C-s, C-q, C-y, C-v. * readline.c -- rl_prep_terminal () SYSV version hacks readline_echoing_p. BSD version turns on passing of the 8th bit for the duration of reading the line. Tue Jul 11 06:25:01 1989 Brian Fox (bfox at aurel) * readline.c: new variable rl_tilde_expander. If non-null, this contains the address of a function to call if the standard meaning for expanding a tilde fails. The function is called with the text sans tilde (as in "foo"), and returns a malloc()'ed string which is the expansion, or a NULL pointer if there is no expansion. * readline.h - new file chardefs.h Separates things that only readline.c needs from the standard header file publishing interesting things about readline. * readline.c: readline_default_bindings () now looks at terminal chararacters and binds those as well. Wed Jun 28 20:20:51 1989 Brian Fox (bfox at aurel) * Made readline and history into independent libraries. lafe/readline/isearch.c100644 325 24 23057 6106101041 13300 0ustar dlduser/* **************************************************************** */ /* */ /* I-Search and Searching */ /* */ /* **************************************************************** */ /* Copyright (C) 1987,1989 Free Software Foundation, Inc. This file contains the Readline Library (the Library), a set of routines for providing Emacs style line input to programs that ask for it. The Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #if defined (HAVE_UNISTD_H) # include #endif #include "memalloc.h" #include "readline.h" #include "history.h" #define STREQ(a, b) (((a)[0] == (b)[0]) && (strcmp ((a), (b)) == 0)) #define STREQN(a, b, n) (((a)[0] == (b)[0]) && (strncmp ((a), (b), (n)) == 0)) /* Variables imported from other files in the readline library. */ extern Keymap _rl_keymap; extern HIST_ENTRY *saved_line_for_history; extern int rl_line_buffer_len; extern int rl_point, rl_end; extern char *rl_line_buffer; extern char *xmalloc (), *xrealloc (); static int rl_search_history (); /* Last line found by the current incremental search, so we don't `find' identical lines many times in a row. */ static char *prev_line_found; /* Search backwards through the history looking for a string which is typed interactively. Start with the current line. */ rl_reverse_search_history (sign, key) int sign; int key; { return (rl_search_history (-sign, key)); } /* Search forwards through the history looking for a string which is typed interactively. Start with the current line. */ rl_forward_search_history (sign, key) int sign; int key; { return (rl_search_history (sign, key)); } /* Display the current state of the search in the echo-area. SEARCH_STRING contains the string that is being searched for, DIRECTION is zero for forward, or 1 for reverse, WHERE is the history list number of the current line. If it is -1, then this line is the starting one. */ static void rl_display_search (search_string, reverse_p, where) char *search_string; int reverse_p, where; { char *message; message = xmalloc (1 + (search_string ? strlen (search_string) : 0) + 30); *message = '\0'; #if defined (NOTDEF) if (where != -1) sprintf (message, "[%d]", where + history_base); #endif /* NOTDEF */ strcat (message, "("); if (reverse_p) strcat (message, "reverse-"); strcat (message, "i-search)`"); if (search_string) strcat (message, search_string); strcat (message, "': "); rl_message ("%s", message, 0); free (message); rl_redisplay (); } /* Search through the history looking for an interactively typed string. This is analogous to i-search. We start the search in the current line. DIRECTION is which direction to search; >= 0 means forward, < 0 means backwards. */ static int rl_search_history (direction, invoking_key) int direction; int invoking_key; { /* The string that the user types in to search for. */ char *search_string; /* The current length of SEARCH_STRING. */ int search_string_index; /* The amount of space that SEARCH_STRING has allocated to it. */ int search_string_size; /* The list of lines to search through. */ char **lines, *allocated_line = (char *)NULL; /* The length of LINES. */ int hlen; /* Where we get LINES from. */ HIST_ENTRY **hlist = history_list (); register int i = 0; int orig_point = rl_point; int orig_line = where_history (); int last_found_line = orig_line; int c, done = 0, found, failed, sline_len; /* The line currently being searched. */ char *sline; /* Offset in that line. */ int line_index; /* Non-zero if we are doing a reverse search. */ int reverse = (direction < 0); /* Create an arrary of pointers to the lines that we want to search. */ maybe_replace_line (); if (hlist) for (i = 0; hlist[i]; i++); /* Allocate space for this many lines, +1 for the current input line, and remember those lines. */ lines = (char **)xmalloc ((1 + (hlen = i)) * sizeof (char *)); for (i = 0; i < hlen; i++) lines[i] = hlist[i]->line; if (saved_line_for_history) lines[i] = saved_line_for_history->line; else { /* Keep track of this so we can free it. */ allocated_line = xmalloc (1 + strlen (rl_line_buffer)); strcpy (allocated_line, &rl_line_buffer[0]); lines[i] = allocated_line; } hlen++; /* The line where we start the search. */ i = orig_line; /* Initialize search parameters. */ search_string = xmalloc (search_string_size = 128); *search_string = '\0'; search_string_index = 0; prev_line_found = (char *)0; /* XXX */ /* Normalize DIRECTION into 1 or -1. */ direction = (direction >= 0) ? 1 : -1; rl_display_search (search_string, reverse, -1); sline = rl_line_buffer; sline_len = strlen (sline); line_index = rl_point; found = failed = 0; while (!done) { Function *f = (Function *)NULL; /* Read a key and decide how to proceed. */ c = rl_read_key (); /* Hack C to Do What I Mean. */ if (_rl_keymap[c].type == ISFUNC) { f = _rl_keymap[c].function; if (f == rl_reverse_search_history) c = reverse ? -1 : -2; else if (f == rl_forward_search_history) c = !reverse ? -1 : -2; } switch (c) { case ESC: done = 1; continue; case -1: if (!search_string_index) continue; else { if (reverse) --line_index; else { if (line_index != sline_len) ++line_index; else ding (); } } break; /* switch directions */ case -2: direction = -direction; reverse = (direction < 0); break; case CTRL ('G'): strcpy (rl_line_buffer, lines[orig_line]); rl_point = orig_point; rl_end = strlen (rl_line_buffer); rl_clear_message (); free (allocated_line); free (lines); return 0; default: if (CTRL_CHAR (c) || META_CHAR (c) || c == RUBOUT) { rl_execute_next (c); done = 1; continue; } else { /* Add character to search string and continue search. */ if (search_string_index + 2 >= search_string_size) { search_string_size += 128; search_string = xrealloc (search_string, search_string_size); } search_string[search_string_index++] = c; search_string[search_string_index] = '\0'; break; } } found = failed = 0; while (1) { int limit = sline_len - search_string_index + 1; /* Search the current line. */ while (reverse ? (line_index >= 0) : (line_index < limit)) { if (STREQN(search_string, sline + line_index, search_string_index)) { found++; break; } else line_index += direction; } if (found) break; /* Move to the next line, but skip new copies of the line we just found and lines shorter than the string we're searching for. */ do { /* Move to the next line. */ i += direction; /* At limit for direction? */ if (reverse ? (i < 0) : (i == hlen)) { failed++; break; } /* We will need these later. */ sline = lines[i]; sline_len = strlen (sline); } while ((prev_line_found && STREQ (prev_line_found, lines[i])) || (search_string_index > sline_len)); if (failed) break; /* Now set up the line for searching... */ if (reverse) line_index = sline_len - search_string_index; else line_index = 0; } if (failed) { /* We cannot find the search string. Ding the bell. */ ding (); i = last_found_line; continue; /* XXX - was break */ } /* We have found the search string. Just display it. But don't actually move there in the history list until the user accepts the location. */ if (found) { int line_len; prev_line_found = lines[i]; line_len = strlen (lines[i]); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (rl_line_buffer, lines[i]); rl_point = line_index; rl_end = line_len; last_found_line = i; rl_display_search (search_string, reverse, (i == orig_line) ? -1 : i); } } /* The searching is over. The user may have found the string that she was looking for, or else she may have exited a failing search. If LINE_INDEX is -1, then that shows that the string searched for was not found. We use this to determine where to place rl_point. */ /* First put back the original state. */ strcpy (rl_line_buffer, lines[orig_line]); /* Free the search string. */ free (search_string); if (last_found_line < orig_line) rl_get_previous_history (orig_line - last_found_line); else rl_get_next_history (last_found_line - orig_line); /* If the string was not found, put point at the end of the line. */ if (line_index < 0) line_index = strlen (rl_line_buffer); rl_point = line_index; rl_clear_message (); free (allocated_line); free (lines); return 0; } lafe/readline/configure.in100644 325 24 2401 6106101042 13776 0ustar dlduserdnl Process this file with autoconf to produce a configure script. AC_INIT(readline.h) AC_CONFIG_HEADER(config.h) AC_REVISION(Configure for Readline 2.0) # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g auto_cflags=1 AC_PROG_CC # If we're using gcc and the user hasn't specified CFLAGS, add -O to CFLAGS. test -n "$GCC" && test -n "$auto_cflags" && CFLAGS="$CFLAGS -O" AC_SUBST(CFLAGS)dnl AC_SUBST(LDFLAGS)dnl AC_GCC_TRADITIONAL AC_PROG_INSTALL AC_PROG_RANLIB AC_USG AC_HAVE_FUNCS(strcasecmp sighold) AC_HAVE_HEADERS(unistd.h stdlib.h varargs.h string.h alloca.h \ dirent.h sys/ptem.h sys/pte.h sys/stream.h termcap.h \ termio.h) AC_HEADER_CHECK(sys/file.h, ,AC_DEFINE(NO_SYS_FILE)) if test -z "$have_tiocgwinsz"; then AC_COMPILE_CHECK(TIOCGWINSZ in sys/ioctl.h, [#include #include ], [int x = TIOCGWINSZ;], AC_DEFINE(GWINSZ_IN_SYS_IOCTL)) fi AC_COMPILE_CHECK(programs able to redeclare getpw functions, [#include #include extern struct passwd *getpwuid();], [struct passwd *z; z = getpwuid(0);], , AC_DEFINE(HAVE_GETPW_DECLS)) AC_ALLOCA AC_OUTPUT(Makefile, [ # Makefile uses this timestamp file to record whether config.h is up to date. touch stamp-config]) lafe/readline/rltty.c100644 325 24 40053 6106101042 13034 0ustar dlduser/* rltty.c -- functions to prepare and restore the terminal for readline's use. */ /* Copyright (C) 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #include "rldefs.h" #include "readline.h" #if !defined (errno) extern int errno; #endif /* !errno */ extern int readline_echoing_p; extern int _rl_eof_char; #if defined (__GO32__) # include # undef HANDLE_SIGNALS #endif /* __GO32__ */ static int output_was_flushed; /* **************************************************************** */ /* */ /* Signal Management */ /* */ /* **************************************************************** */ #if defined (HAVE_POSIX_SIGNALS) static sigset_t sigint_set, sigint_oset; #else /* !HAVE_POSIX_SIGNALS */ # if defined (HAVE_BSD_SIGNALS) static int sigint_oldmask; # endif /* HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ static int sigint_blocked = 0; /* Cause SIGINT to not be delivered until the corresponding call to release_sigint(). */ static void block_sigint () { if (sigint_blocked) return; #if defined (HAVE_POSIX_SIGNALS) sigemptyset (&sigint_set); sigemptyset (&sigint_oset); sigaddset (&sigint_set, SIGINT); sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset); #else /* !HAVE_POSIX_SIGNALS */ # if defined (HAVE_BSD_SIGNALS) sigint_oldmask = sigblock (sigmask (SIGINT)); # else /* !HAVE_BSD_SIGNALS */ # if defined (HAVE_USG_SIGHOLD) sighold (SIGINT); # endif /* HAVE_USG_SIGHOLD */ # endif /* !HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ sigint_blocked = 1; } /* Allow SIGINT to be delivered. */ static void release_sigint () { if (!sigint_blocked) return; #if defined (HAVE_POSIX_SIGNALS) sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL); #else # if defined (HAVE_BSD_SIGNALS) sigsetmask (sigint_oldmask); # else /* !HAVE_BSD_SIGNALS */ # if defined (HAVE_USG_SIGHOLD) sigrelse (SIGINT); # endif /* HAVE_USG_SIGHOLD */ # endif /* !HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ sigint_blocked = 0; } /* **************************************************************** */ /* */ /* Controlling the Meta Key and Keypad */ /* */ /* **************************************************************** */ extern int term_has_meta; extern char *term_mm; extern char *term_mo; extern char *term_ks; extern char *term_ke; static int outchar (c) int c; { return putc (c, rl_outstream); } /* Turn on/off the meta key depending on ON. */ static void control_meta_key (on) int on; { if (term_has_meta) { if (on && term_mm) tputs (term_mm, 1, outchar); else if (!on && term_mo) tputs (term_mo, 1, outchar); } } static void control_keypad (on) int on; { if (on && term_ks) tputs (term_ks, 1, outchar); else if (!on && term_ke) tputs (term_ke, 1, outchar); } /* **************************************************************** */ /* */ /* Saving and Restoring the TTY */ /* */ /* **************************************************************** */ /* Non-zero means that the terminal is in a prepped state. */ static int terminal_prepped = 0; /* If non-zero, means that this process has called tcflow(fd, TCOOFF) and output is suspended. */ #if defined (__ksr1__) static int ksrflow = 0; #endif #if defined (NEW_TTY_DRIVER) /* Values for the `flags' field of a struct bsdtty. This tells which elements of the struct bsdtty have been fetched from the system and are valid. */ #define SGTTY_SET 0x01 #define LFLAG_SET 0x02 #define TCHARS_SET 0x04 #define LTCHARS_SET 0x08 struct bsdtty { struct sgttyb sgttyb; /* Basic BSD tty driver information. */ int lflag; /* Local mode flags, like LPASS8. */ #if defined (TIOCGETC) struct tchars tchars; /* Terminal special characters, including ^S and ^Q. */ #endif #if defined (TIOCGLTC) struct ltchars ltchars; /* 4.2 BSD editing characters */ #endif int flags; /* Bitmap saying which parts of the struct are valid. */ }; #define TIOTYPE struct bsdtty static TIOTYPE otio; static int get_tty_settings (tty, tiop) int tty; TIOTYPE *tiop; { #if !defined (SHELL) && defined (TIOCGWINSZ) struct winsize w; if (ioctl (tty, TIOCGWINSZ, &w) == 0) (void) ioctl (tty, TIOCSWINSZ, &w); #endif tiop->flags = tiop->lflag = 0; ioctl (tty, TIOCGETP, &(tiop->sgttyb)); tiop->flags |= SGTTY_SET; #if defined (TIOCLGET) ioctl (tty, TIOCLGET, &(tiop->lflag)); tiop->flags |= LFLAG_SET; #endif #if defined (TIOCGETC) ioctl (tty, TIOCGETC, &(tiop->tchars)); tiop->flags |= TCHARS_SET; #endif #if defined (TIOCGLTC) ioctl (tty, TIOCGLTC, &(tiop->ltchars)); tiop->flags |= LTCHARS_SET; #endif return 0; } set_tty_settings (tty, tiop) int tty; TIOTYPE *tiop; { if (tiop->flags & SGTTY_SET) { ioctl (tty, TIOCSETN, &(tiop->sgttyb)); tiop->flags &= ~SGTTY_SET; } readline_echoing_p = 1; #if defined (TIOCLSET) if (tiop->flags & LFLAG_SET) { ioctl (tty, TIOCLSET, &(tiop->lflag)); tiop->flags &= ~LFLAG_SET; } #endif #if defined (TIOCSETC) if (tiop->flags & TCHARS_SET) { ioctl (tty, TIOCSETC, &(tiop->tchars)); tiop->flags &= ~TCHARS_SET; } #endif #if defined (TIOCSLTC) if (tiop->flags & LTCHARS_SET) { ioctl (tty, TIOCSLTC, &(tiop->ltchars)); tiop->flags &= ~LTCHARS_SET; } #endif return 0; } static void prepare_terminal_settings (meta_flag, otio, tiop) int meta_flag; TIOTYPE otio, *tiop; { #if !defined (__GO32__) readline_echoing_p = (otio.sgttyb.sg_flags & ECHO); /* Copy the original settings to the structure we're going to use for our settings. */ tiop->sgttyb = otio.sgttyb; tiop->lflag = otio.lflag; #if defined (TIOCGETC) tiop->tchars = otio.tchars; #endif #if defined (TIOCGLTC) tiop->ltchars = otio.ltchars; #endif tiop->flags = otio.flags; /* First, the basic settings to put us into character-at-a-time, no-echo input mode. */ tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD); tiop->sgttyb.sg_flags |= CBREAK; /* If this terminal doesn't care how the 8th bit is used, then we can use it for the meta-key. If only one of even or odd parity is specified, then the terminal is using parity, and we cannot. */ #if !defined (ANYP) # define ANYP (EVENP | ODDP) #endif if (((otio.sgttyb.sg_flags & ANYP) == ANYP) || ((otio.sgttyb.sg_flags & ANYP) == 0)) { tiop->sgttyb.sg_flags |= ANYP; /* Hack on local mode flags if we can. */ #if defined (TIOCLGET) # if defined (LPASS8) tiop->lflag |= LPASS8; # endif /* LPASS8 */ #endif /* TIOCLGET */ } #if defined (TIOCGETC) # if defined (USE_XON_XOFF) /* Get rid of terminal output start and stop characters. */ tiop->tchars.t_stopc = -1; /* C-s */ tiop->tchars.t_startc = -1; /* C-q */ /* If there is an XON character, bind it to restart the output. */ if (otio.tchars.t_startc != -1) rl_bind_key (otio.tchars.t_startc, rl_restart_output); # endif /* USE_XON_XOFF */ /* If there is an EOF char, bind _rl_eof_char to it. */ if (otio.tchars.t_eofc != -1) _rl_eof_char = otio.tchars.t_eofc; # if defined (NO_KILL_INTR) /* Get rid of terminal-generated SIGQUIT and SIGINT. */ tiop->tchars.t_quitc = -1; /* C-\ */ tiop->tchars.t_intrc = -1; /* C-c */ # endif /* NO_KILL_INTR */ #endif /* TIOCGETC */ #if defined (TIOCGLTC) /* Make the interrupt keys go away. Just enough to make people happy. */ tiop->ltchars.t_dsuspc = -1; /* C-y */ tiop->ltchars.t_lnextc = -1; /* C-v */ #endif /* TIOCGLTC */ #endif /* !__GO32__ */ } #else /* !defined (NEW_TTY_DRIVER) */ #if !defined (VMIN) # define VMIN VEOF #endif #if !defined (VTIME) # define VTIME VEOL #endif #if defined (TERMIOS_TTY_DRIVER) # define TIOTYPE struct termios # define DRAIN_OUTPUT(fd) tcdrain (fd) # define GETATTR(tty, tiop) (tcgetattr (tty, tiop)) # define SETATTR(tty, tiop) (tcsetattr (tty, TCSANOW, tiop)) #else # define TIOTYPE struct termio # define DRAIN_OUTPUT(fd) # define GETATTR(tty, tiop) (ioctl (tty, TCGETA, tiop)) # define SETATTR(tty, tiop) (ioctl (tty, TCSETA, tiop)) #endif /* !TERMIOS_TTY_DRIVER */ static TIOTYPE otio; #if defined (FLUSHO) # define OUTPUT_BEING_FLUSHED(tp) (tp->c_lflag & FLUSHO) #else # define OUTPUT_BEING_FLUSHED(tp) 0 #endif static int get_tty_settings (tty, tiop) int tty; TIOTYPE *tiop; { #if !defined (SHELL) && defined (TIOCGWINSZ) struct winsize w; if (ioctl (tty, TIOCGWINSZ, &w) == 0) (void) ioctl (tty, TIOCSWINSZ, &w); #endif /* Keep looping if output is being flushed after a ^O (or whatever the flush character is). */ while (GETATTR (tty, tiop) < 0 || OUTPUT_BEING_FLUSHED (tiop)) { if (OUTPUT_BEING_FLUSHED (tiop)) continue; if (errno != EINTR) return -1; errno = 0; } return 0; } static int set_tty_settings (tty, tiop) int tty; TIOTYPE *tiop; { while (SETATTR (tty, tiop) < 0) { if (errno != EINTR) return -1; errno = 0; } #if 0 #if defined (TERMIOS_TTY_DRIVER) # if defined (__ksr1__) if (ksrflow) { ksrflow = 0; tcflow (tty, TCOON); } # else /* !ksr1 */ tcflow (tty, TCOON); /* Simulate a ^Q. */ # endif /* !ksr1 */ #else ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */ #endif /* !TERMIOS_TTY_DRIVER */ #endif return 0; } static void prepare_terminal_settings (meta_flag, otio, tiop) int meta_flag; TIOTYPE otio, *tiop; { readline_echoing_p = (otio.c_lflag & ECHO); tiop->c_lflag &= ~(ICANON | ECHO); if ((unsigned char) otio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE) _rl_eof_char = otio.c_cc[VEOF]; #if defined (USE_XON_XOFF) #if defined (IXANY) tiop->c_iflag &= ~(IXON | IXOFF | IXANY); #else /* `strict' Posix systems do not define IXANY. */ tiop->c_iflag &= ~(IXON | IXOFF); #endif /* IXANY */ #endif /* USE_XON_XOFF */ /* Only turn this off if we are using all 8 bits. */ if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag) tiop->c_iflag &= ~(ISTRIP | INPCK); /* Make sure we differentiate between CR and NL on input. */ tiop->c_iflag &= ~(ICRNL | INLCR); #if !defined (HANDLE_SIGNALS) tiop->c_lflag &= ~ISIG; #else tiop->c_lflag |= ISIG; #endif tiop->c_cc[VMIN] = 1; tiop->c_cc[VTIME] = 0; if (tiop->c_lflag & FLUSHO) { output_was_flushed = 1; tiop->c_lflag &= ~FLUSHO; otio.c_lflag &= ~FLUSHO; } /* Turn off characters that we need on Posix systems with job control, just to be sure. This includes ^Y and ^V. This should not really be necessary. */ #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE) #if defined (VLNEXT) tiop->c_cc[VLNEXT] = _POSIX_VDISABLE; #endif #if defined (VDSUSP) tiop->c_cc[VDSUSP] = _POSIX_VDISABLE; #endif #endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */ } #endif /* NEW_TTY_DRIVER */ /* Put the terminal in CBREAK mode so that we can detect key presses. */ void rl_prep_terminal (meta_flag) int meta_flag; { #if !defined (__GO32__) int tty = fileno (rl_instream); TIOTYPE tio; if (terminal_prepped) return; /* Try to keep this function from being INTerrupted. */ block_sigint (); if (get_tty_settings (tty, &tio) < 0) { release_sigint (); return; } otio = tio; prepare_terminal_settings (meta_flag, otio, &tio); if (set_tty_settings (tty, &tio) < 0) { release_sigint (); return; } if (output_was_flushed) output_was_flushed = 0; control_meta_key (1); control_keypad (1); fflush (rl_outstream); terminal_prepped = 1; release_sigint (); #endif /* !__GO32__ */ } /* Restore the terminal's normal settings and modes. */ void rl_deprep_terminal () { #if !defined (__GO32__) int tty = fileno (rl_instream); if (!terminal_prepped) return; /* Try to keep this function from being INTerrupted. */ block_sigint (); if (set_tty_settings (tty, &otio) < 0) { release_sigint (); return; } control_meta_key (0); control_keypad (0); fflush (rl_outstream); terminal_prepped = 0; release_sigint (); #endif /* !__GO32__ */ } /* **************************************************************** */ /* */ /* Bogus Flow Control */ /* */ /* **************************************************************** */ rl_restart_output (count, key) int count, key; { int fildes = fileno (rl_outstream); #if defined (TIOCSTART) #if defined (apollo) ioctl (&fildes, TIOCSTART, 0); #else ioctl (fildes, TIOCSTART, 0); #endif /* apollo */ #else /* !TIOCSTART */ # if defined (TERMIOS_TTY_DRIVER) # if defined (__ksr1__) if (ksrflow) { ksrflow = 0; tcflow (fildes, TCOON); } # else /* !ksr1 */ tcflow (fildes, TCOON); /* Simulate a ^Q. */ # endif /* !ksr1 */ # else /* !TERMIOS_TTY_DRIVER */ # if defined (TCXONC) ioctl (fildes, TCXONC, TCOON); # endif /* TCXONC */ # endif /* !TERMIOS_TTY_DRIVER */ #endif /* !TIOCSTART */ return 0; } rl_stop_output (count, key) int count, key; { int fildes = fileno (rl_instream); #if defined (TIOCSTOP) # if defined (apollo) ioctl (&fildes, TIOCSTOP, 0); # else ioctl (fildes, TIOCSTOP, 0); # endif /* apollo */ #else /* !TIOCSTOP */ # if defined (TERMIOS_TTY_DRIVER) # if defined (__ksr1__) ksrflow = 1; # endif /* ksr1 */ tcflow (fildes, TCOOFF); # else # if defined (TCXONC) ioctl (fildes, TCXONC, TCOON); # endif /* TCXONC */ # endif /* !TERMIOS_TTY_DRIVER */ #endif /* !TIOCSTOP */ return 0; } /* **************************************************************** */ /* */ /* Default Key Bindings */ /* */ /* **************************************************************** */ void rltty_set_default_bindings (kmap) Keymap kmap; { TIOTYPE ttybuff; int tty = fileno (rl_instream); #if defined (NEW_TTY_DRIVER) #define SET_SPECIAL(sc, func) \ do \ { \ int ic; \ ic = sc; \ if (ic != -1 && kmap[ic].type == ISFUNC) \ kmap[ic].function = func; \ } \ while (0) if (get_tty_settings (tty, &ttybuff) == 0) { if (ttybuff.flags & SGTTY_SET) { SET_SPECIAL (ttybuff.sgttyb.sg_erase, rl_rubout); SET_SPECIAL (ttybuff.sgttyb.sg_kill, rl_unix_line_discard); } # if defined (TIOCGLTC) if (ttybuff.flags & LTCHARS_SET) { SET_SPECIAL (ttybuff.ltchars.t_werasc, rl_unix_word_rubout); SET_SPECIAL (ttybuff.ltchars.t_lnextc, rl_quoted_insert); } # endif /* TIOCGLTC */ } #else /* !NEW_TTY_DRIVER */ #define SET_SPECIAL(sc, func) \ do \ { \ unsigned char uc; \ uc = ttybuff.c_cc[sc]; \ if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC) \ kmap[uc].function = func; \ } \ while (0) if (get_tty_settings (tty, &ttybuff) == 0) { SET_SPECIAL (VERASE, rl_rubout); SET_SPECIAL (VKILL, rl_unix_line_discard); # if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER) SET_SPECIAL (VLNEXT, rl_quoted_insert); # endif /* VLNEXT && TERMIOS_TTY_DRIVER */ # if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER) SET_SPECIAL (VWERASE, rl_unix_word_rubout); # endif /* VWERASE && TERMIOS_TTY_DRIVER */ } #endif /* !NEW_TTY_DRIVER */ } lafe/readline/README100644 325 24 424 6106101042 12330 0ustar dlduserThis is the distribution of the Gnu Readline library. See the file STANDALONE for a description of the #defines that can be passed via the makefile to build readline on different systems. The file rlconf.h contains defines that enable and disable certain readline features. lafe/readline/rldefs.h100644 325 24 14741 6106101042 13147 0ustar dlduser/* rldefs.h -- an attempt to isolate some of the system-specific defines for readline. This should be included after any files that define system-specific constants like _POSIX_VERSION or USG. */ /* Copyright (C) 1987,1989 Free Software Foundation, Inc. This file contains the Readline Library (the Library), a set of routines for providing Emacs style line input to programs that ask for it. The Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (_RLDEFS_H) #define _RLDEFS_H #if defined (HAVE_CONFIG_H) # include "config.h" #endif #if !defined (PRAGMA_ALLOCA) # include "memalloc.h" #endif #define NEW_TTY_DRIVER #define HAVE_POSIX_SIGNALS /* #define USE_XON_XOFF */ #if defined (__linux__) || defined (HAVE_TERMCAP_H) # include #endif /* __linux__ || HAVE_TERMCAP_H */ /* Some USG machines have BSD signal handling (sigblock, sigsetmask, etc.) */ #if defined (USG) && !defined (hpux) # undef HAVE_BSD_SIGNALS #endif /* System V machines use termio. */ #if !defined (_POSIX_VERSION) # if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi) || \ defined (DGUX) || defined (HAVE_TERMIO_H) # undef NEW_TTY_DRIVER # define TERMIO_TTY_DRIVER # include # if !defined (TCOON) # define TCOON 1 # endif # endif /* USG || hpux || Xenix || sgi || DUGX || HAVE_TERMIO_H */ #endif /* !_POSIX_VERSION */ /* Posix systems use termios and the Posix signal functions. */ #if defined (_POSIX_VERSION) # if !defined (TERMIOS_MISSING) # undef NEW_TTY_DRIVER # define TERMIOS_TTY_DRIVER # include # endif /* !TERMIOS_MISSING */ # define HAVE_POSIX_SIGNALS # if !defined (O_NDELAY) # define O_NDELAY O_NONBLOCK /* Posix-style non-blocking i/o */ # endif /* O_NDELAY */ #endif /* _POSIX_VERSION */ /* System V.3 machines have the old 4.1 BSD `reliable' signal interface. */ #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS) # if defined (USGr3) && !defined (XENIX_22) # if !defined (HAVE_USG_SIGHOLD) # define HAVE_USG_SIGHOLD # endif /* !HAVE_USG_SIGHOLD */ # endif /* USGr3 && !XENIX_22 */ #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */ /* Other (BSD) machines use sgtty. */ #if defined (NEW_TTY_DRIVER) # include #endif /* Define _POSIX_VDISABLE if we are not using the `new' tty driver and it is not already defined. It is used both to determine if a special character is disabled and to disable certain special characters. Posix systems should set to 0, USG systems to -1. */ #if !defined (NEW_TTY_DRIVER) && !defined (_POSIX_VDISABLE) # if defined (_POSIX_VERSION) # define _POSIX_VDISABLE 0 # else /* !_POSIX_VERSION */ # define _POSIX_VDISABLE -1 # endif /* !_POSIX_VERSION */ #endif /* !NEW_TTY_DRIVER && !_POSIX_VDISABLE */ #if !defined (SHELL) && (defined (_POSIX_VERSION) || defined (USGr3)) # if !defined (HAVE_DIRENT_H) # define HAVE_DIRENT_H # endif /* !HAVE_DIRENT_H */ #endif /* !SHELL && (_POSIX_VERSION || USGr3) */ #if defined (HAVE_DIRENT_H) # include # define D_NAMLEN(d) strlen ((d)->d_name) #else /* !HAVE_DIRENT_H */ # define D_NAMLEN(d) ((d)->d_namlen) # if defined (USG) # if defined (Xenix) # include # else /* !Xenix (but USG...) */ # include "ndir.h" # endif /* !Xenix */ # else /* !USG */ # include # endif /* !USG */ # if !defined (dirent) # define dirent direct # endif /* !dirent */ #endif /* !HAVE_DIRENT_H */ #if defined (USG) && defined (TIOCGWINSZ) && !defined (Linux) # if defined (HAVE_SYS_STREAM_H) # include # endif /* HAVE_SYS_STREAM_H */ # if defined (HAVE_SYS_PTEM_H) # include # endif /* HAVE_SYS_PTEM_H */ # if defined (HAVE_SYS_PTE_H) # include # endif /* HAVE_SYS_PTE_H */ #endif /* USG && TIOCGWINSZ && !Linux */ /* Posix macro to check file in statbuf for directory-ness. This requires that be included before this test. */ #if defined (S_IFDIR) && !defined (S_ISDIR) # define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR) #endif /* Decide which flavor of the header file describing the C library string functions to include and include it. */ #if defined (USG) || defined (NeXT) # if !defined (HAVE_STRING_H) # define HAVE_STRING_H # endif /* !HAVE_STRING_H */ #endif /* USG || NeXT */ #if defined (HAVE_STRING_H) # include #else /* !HAVE_STRING_H */ # include #endif /* !HAVE_STRING_H */ #if !defined (strchr) && !defined (__STDC__) extern char *strchr (), *strrchr (); #endif /* !strchr && !__STDC__ */ #if defined (HAVE_VARARGS_H) # include #endif /* HAVE_VARARGS_H */ /* This is needed to include support for TIOCGWINSZ and window resizing. */ #if defined (OSF1) || defined (BSD386) || defined (NetBSD) || \ defined (__BSD_4_4__) || defined (FreeBSD) || defined (_386BSD) || \ defined (AIX) # define GWINSZ_IN_SYS_IOCTL #endif #if !defined (emacs_mode) # define no_mode -1 # define vi_mode 0 # define emacs_mode 1 #endif /* If you cast map[key].function to type (Keymap) on a Cray, the compiler takes the value of map[key].function and divides it by 4 to convert between pointer types (pointers to functions and pointers to structs are different sizes). This is not what is wanted. */ #if defined (CRAY) # define FUNCTION_TO_KEYMAP(map, key) (Keymap)((int)map[key].function) # define KEYMAP_TO_FUNCTION(data) (Function *)((int)(data)) #else # define FUNCTION_TO_KEYMAP(map, key) (Keymap)(map[key].function) # define KEYMAP_TO_FUNCTION(data) (Function *)(data) #endif #ifndef savestring extern char *xmalloc (); #define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x)) #endif /* Possible values for _rl_bell_preference. */ #define NO_BELL 0 #define AUDIBLE_BELL 1 #define VISIBLE_BELL 2 /* CONFIGURATION SECTION */ #include "rlconf.h" #endif /* !_RLDEFS_H */ lafe/readline/parens.c100644 325 24 6600 6106101042 13126 0ustar dlduser/* parens.c -- Implemenation of matching parenthesis feature. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include "rlconf.h" #if !defined (PAREN_MATCHING) rl_insert_close (count, invoking_key) int count, invoking_key; { return (rl_insert (count, invoking_key)); } #else /* PAREN_MATCHING */ #include #include #if defined (FD_SET) # include #endif /* FD_SET */ #include "readline.h" extern int rl_explicit_arg; /* Non-zero means try to blink the matching open parenthesis when the close parenthesis is inserted. */ #if defined (FD_SET) int rl_blink_matching_paren = 1; #else /* !FD_SET */ int rl_blink_matching_paren = 0; #endif /* !FD_SET */ static int find_matching_open (); rl_insert_close (count, invoking_key) int count, invoking_key; { if (rl_explicit_arg || !rl_blink_matching_paren) rl_insert (count, invoking_key); else { #if defined (FD_SET) int orig_point, match_point, ready; struct timeval timer; fd_set readfds; rl_insert (1, invoking_key); rl_redisplay (); match_point = find_matching_open (rl_line_buffer, rl_point - 2, invoking_key); /* Emacs might message or ring the bell here, but I don't. */ if (match_point < 0) return -1; FD_ZERO (&readfds); FD_SET (fileno (rl_instream), &readfds); timer.tv_sec = 1; timer.tv_usec = 500; orig_point = rl_point; rl_point = match_point; rl_redisplay (); ready = select (1, &readfds, (fd_set *)NULL, (fd_set *)NULL, &timer); rl_point = orig_point; #else /* !FD_SET */ rl_insert (count, invoking_key); #endif /* !FD_SET */ } return 0; } static int find_matching_open (string, from, closer) char *string; int from, closer; { register int i; int opener, level, delimiter; switch (closer) { case ']': opener = '['; break; case '}': opener = '{'; break; case ')': opener = '('; break; default: return (-1); } level = 1; /* The closer passed in counts as 1. */ delimiter = 0; /* Delimited state unknown. */ for (i = from; i > -1; i--) { if (delimiter && (string[i] == delimiter)) delimiter = 0; else if ((string[i] == '\'') || (string[i] == '"')) delimiter = rl_line_buffer[i]; else if (!delimiter && (string[i] == closer)) level++; else if (!delimiter && (string[i] == opener)) level--; if (!level) break; } return (i); } #endif /* PAREN_MATCHING */ lafe/readline/signals.c100644 325 24 16556 6106101042 13331 0ustar dlduser/* signals.c -- signal handling support for readline. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #if !defined (NO_SYS_FILE) # include #endif /* !NO_SYS_FILE */ #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" #if defined (GWINSZ_IN_SYS_IOCTL) # include #endif /* GWINSZ_IN_SYS_IOCTL */ /* Some standard library routines. */ #include "readline.h" #include "history.h" static void cr (); extern int readline_echoing_p; extern int rl_pending_input; extern char *term_cr; extern int _rl_meta_flag; extern int _rl_output_character_function (); extern void free_undo_list (); #if defined (VOID_SIGHANDLER) # define sighandler void #else # define sighandler int #endif /* VOID_SIGHANDLER */ /* This typedef is equivalant to the one for Function; it allows us to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */ typedef sighandler SigHandler (); #if defined (__GO32__) # undef HANDLE_SIGNALS #endif /* __GO32__ */ #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Signal Handling */ /* */ /* **************************************************************** */ #if defined (SIGWINCH) static SigHandler *old_sigwinch = (SigHandler *)NULL; static sighandler rl_handle_sigwinch (sig) int sig; { if (readline_echoing_p) { _rl_set_screen_size (fileno (rl_instream), 1); cr (); /* was crlf () */ rl_forced_update_display (); } if (old_sigwinch && old_sigwinch != (SigHandler *)SIG_IGN && old_sigwinch != (SigHandler *)SIG_DFL) (*old_sigwinch) (sig); #if !defined (VOID_SIGHANDLER) return (0); #endif /* VOID_SIGHANDLER */ } #endif /* SIGWINCH */ #if defined (HANDLE_SIGNALS) /* Interrupt handling. */ static SigHandler *old_int = (SigHandler *)NULL, *old_alrm = (SigHandler *)NULL; #if !defined (SHELL) static SigHandler *old_tstp = (SigHandler *)NULL, *old_ttou = (SigHandler *)NULL, *old_ttin = (SigHandler *)NULL, *old_cont = (SigHandler *)NULL; #endif /* !SHELL */ /* Handle an interrupt character. */ static sighandler rl_signal_handler (sig) int sig; { #if defined (HAVE_POSIX_SIGNALS) sigset_t set; #else /* !HAVE_POSIX_SIGNALS */ # if defined (HAVE_BSD_SIGNALS) long omask; # endif /* HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS) /* Since the signal will not be blocked while we are in the signal handler, ignore it until rl_clear_signals resets the catcher. */ if (sig == SIGINT) signal (sig, SIG_IGN); #endif /* !HAVE_BSD_SIGNALS */ switch (sig) { case SIGINT: { register HIST_ENTRY *entry; free_undo_list (); entry = current_history (); if (entry) entry->data = (char *)NULL; } _rl_kill_kbd_macro (); rl_clear_message (); rl_init_argument (); #if defined (SIGTSTP) case SIGTSTP: case SIGTTOU: case SIGTTIN: #endif /* SIGTSTP */ case SIGALRM: rl_clean_up_for_exit (); rl_deprep_terminal (); rl_clear_signals (); rl_pending_input = 0; #if defined (HAVE_POSIX_SIGNALS) sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set); sigdelset (&set, sig); #else /* !HAVE_POSIX_SIGNALS */ # if defined (HAVE_BSD_SIGNALS) omask = sigblock (0); # endif /* HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ kill (getpid (), sig); /* Let the signal that we just sent through. */ #if defined (HAVE_POSIX_SIGNALS) sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL); #else /* !HAVE_POSIX_SIGNALS */ # if defined (HAVE_BSD_SIGNALS) sigsetmask (omask & ~(sigmask (sig))); # endif /* HAVE_BSD_SIGNALS */ #endif /* !HAVE_POSIX_SIGNALS */ rl_prep_terminal (_rl_meta_flag); rl_set_signals (); } #if !defined (VOID_SIGHANDLER) return (0); #endif /* !VOID_SIGHANDLER */ } #if defined (HAVE_POSIX_SIGNALS) static SigHandler * rl_set_sighandler (sig, handler) int sig; SigHandler *handler; { struct sigaction act, oact; act.sa_handler = handler; act.sa_flags = 0; sigemptyset (&act.sa_mask); sigemptyset (&oact.sa_mask); sigaction (sig, &act, &oact); return (oact.sa_handler); } #else /* !HAVE_POSIX_SIGNALS */ # define rl_set_sighandler(sig, handler) (SigHandler *)signal (sig, handler) #endif /* !HAVE_POSIX_SIGNALS */ rl_set_signals () { old_int = (SigHandler *)rl_set_sighandler (SIGINT, rl_signal_handler); if (old_int == (SigHandler *)SIG_IGN) signal (SIGINT, SIG_IGN); old_alrm = (SigHandler *)rl_set_sighandler (SIGALRM, rl_signal_handler); if (old_alrm == (SigHandler *)SIG_IGN) signal (SIGALRM, SIG_IGN); #if !defined (SHELL) #if defined (SIGTSTP) old_tstp = (SigHandler *)rl_set_sighandler (SIGTSTP, rl_signal_handler); if (old_tstp == (SigHandler *)SIG_IGN) signal (SIGTSTP, SIG_IGN); #endif /* SIGTSTP */ #if defined (SIGTTOU) old_ttou = (SigHandler *)rl_set_sighandler (SIGTTOU, rl_signal_handler); old_ttin = (SigHandler *)rl_set_sighandler (SIGTTIN, rl_signal_handler); if (old_tstp == (SigHandler *)SIG_IGN) { signal (SIGTTOU, SIG_IGN); signal (SIGTTIN, SIG_IGN); } #endif /* SIGTTOU */ #endif /* !SHELL */ #if defined (SIGWINCH) old_sigwinch = (SigHandler *) rl_set_sighandler (SIGWINCH, rl_handle_sigwinch); #endif /* SIGWINCH */ return 0; } rl_clear_signals () { rl_set_sighandler (SIGINT, old_int); rl_set_sighandler (SIGALRM, old_alrm); #if !defined (SHELL) #if defined (SIGTSTP) signal (SIGTSTP, old_tstp); #endif #if defined (SIGTTOU) signal (SIGTTOU, old_ttou); signal (SIGTTIN, old_ttin); #endif /* SIGTTOU */ #endif /* !SHELL */ #if defined (SIGWINCH) signal (SIGWINCH, old_sigwinch); #endif return 0; } /* Move to the start of the current line. */ static void cr () { if (term_cr) tputs (term_cr, 1, _rl_output_character_function); } #endif /* HANDLE_SIGNALS */ lafe/readline/keymaps.h100644 325 24 6232 6106101042 13315 0ustar dlduser/* keymaps.h -- Manipulation of readline keymaps. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _KEYMAPS_H_ #define _KEYMAPS_H_ #if defined (READLINE_LIBRARY) # include "chardefs.h" #else # include #endif #if !defined (__FUNCTION_DEF) # define __FUNCTION_DEF typedef int Function (); typedef void VFunction (); typedef char *CPFunction (); typedef char **CPPFunction (); #endif /* A keymap contains one entry for each key in the ASCII set. Each entry consists of a type and a pointer. POINTER is the address of a function to run, or the address of a keymap to indirect through. TYPE says which kind of thing POINTER is. */ typedef struct _keymap_entry { char type; Function *function; } KEYMAP_ENTRY; /* This must be large enough to hold bindings for all of the characters in a desired character set (e.g, 128 for ASCII, 256 for ISO Latin-x, and so on). */ #define KEYMAP_SIZE 256 /* I wanted to make the above structure contain a union of: union { Function *function; struct _keymap_entry *keymap; } value; but this made it impossible for me to create a static array. Maybe I need C lessons. */ typedef KEYMAP_ENTRY KEYMAP_ENTRY_ARRAY[KEYMAP_SIZE]; typedef KEYMAP_ENTRY *Keymap; /* The values that TYPE can have in a keymap entry. */ #define ISFUNC 0 #define ISKMAP 1 #define ISMACR 2 extern KEYMAP_ENTRY_ARRAY emacs_standard_keymap, emacs_meta_keymap, emacs_ctlx_keymap; extern KEYMAP_ENTRY_ARRAY vi_insertion_keymap, vi_movement_keymap; /* Return a new, empty keymap. Free it with free() when you are done. */ extern Keymap rl_make_bare_keymap (); /* Return a new keymap which is a copy of MAP. */ extern Keymap rl_copy_keymap (); /* Return a new keymap with the printing characters bound to rl_insert, the lowercase Meta characters bound to run their equivalents, and the Meta digits bound to produce numeric arguments. */ extern Keymap rl_make_keymap (); extern void rl_discard_keymap (); /* Return the keymap corresponding to a given name. Names look like `emacs' or `emacs-meta' or `vi-insert'. */ extern Keymap rl_get_keymap_by_name (); /* Return the current keymap. */ extern Keymap rl_get_keymap (); /* Set the current keymap to MAP. */ extern void rl_set_keymap (); #endif /* _KEYMAPS_H_ */ lafe/readline/keymaps.c100644 325 24 10644 6106101042 13332 0ustar dlduser/* keymaps.c -- Functions and keymaps for the GNU Readline library. */ /* Copyright (C) 1988,1989 Free Software Foundation, Inc. This file is part of GNU Readline, a library for reading lines of text with interactive input and history editing. Readline is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. Readline is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Readline; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include "rlconf.h" #include "keymaps.h" #include "emacs_keymap.c" #if defined (VI_MODE) #include "vi_keymap.c" #endif extern int rl_do_lowercase_version (); extern int rl_rubout (), rl_insert (); #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Functions for manipulating Keymaps. */ /* */ /* **************************************************************** */ /* Return a new, empty keymap. Free it with free() when you are done. */ Keymap rl_make_bare_keymap () { register int i; Keymap keymap = (Keymap)xmalloc (KEYMAP_SIZE * sizeof (KEYMAP_ENTRY)); for (i = 0; i < KEYMAP_SIZE; i++) { keymap[i].type = ISFUNC; keymap[i].function = (Function *)NULL; } for (i = 'A'; i < ('Z' + 1); i++) { keymap[i].type = ISFUNC; keymap[i].function = rl_do_lowercase_version; } return (keymap); } /* Return a new keymap which is a copy of MAP. */ Keymap rl_copy_keymap (map) Keymap map; { register int i; Keymap temp = rl_make_bare_keymap (); for (i = 0; i < KEYMAP_SIZE; i++) { temp[i].type = map[i].type; temp[i].function = map[i].function; } return (temp); } /* Return a new keymap with the printing characters bound to rl_insert, the uppercase Meta characters bound to run their lowercase equivalents, and the Meta digits bound to produce numeric arguments. */ Keymap rl_make_keymap () { register int i; Keymap newmap; newmap = rl_make_bare_keymap (); /* All ASCII printing characters are self-inserting. */ for (i = ' '; i < 126; i++) newmap[i].function = rl_insert; newmap[TAB].function = rl_insert; newmap[RUBOUT].function = rl_rubout; newmap[CTRL('H')].function = rl_rubout; #if KEYMAP_SIZE > 128 /* Printing characters in some 8-bit character sets. */ for (i = 128; i < 160; i++) newmap[i].function = rl_insert; /* ISO Latin-1 printing characters should self-insert. */ for (i = 160; i < 256; i++) newmap[i].function = rl_insert; #endif /* KEYMAP_SIZE > 128 */ return (newmap); } /* Free the storage associated with MAP. */ void rl_discard_keymap (map) Keymap (map); { int i; if (!map) return; for (i = 0; i < KEYMAP_SIZE; i++) { switch (map[i].type) { case ISFUNC: break; case ISKMAP: rl_discard_keymap ((Keymap)map[i].function); break; case ISMACR: free ((char *)map[i].function); break; } } } #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ lafe/readline/vi_mode.c100644 325 24 66273 6106101042 13314 0ustar dlduser/* vi_mode.c -- A vi emulation mode for Bash. Derived from code written by Jeff Sparkes (jsparkes@bnr.ca). */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY /* **************************************************************** */ /* */ /* VI Emulation Mode */ /* */ /* **************************************************************** */ #include "rlconf.h" #if defined (VI_MODE) #include #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #if defined (HAVE_UNISTD_H) # include #endif #include /* Some standard library routines. */ #include "rldefs.h" #include "readline.h" #include "history.h" #ifndef digit_p #define digit_p(c) ((c) >= '0' && (c) <= '9') #endif #ifndef digit_value #define digit_value(c) ((c) - '0') #endif #ifndef member #define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0) #endif #ifndef isident #define isident(c) ((pure_alphabetic (c) || digit_p (c) || c == '_')) #endif #ifndef exchange #define exchange(x, y) do {int temp = x; x = y; y = temp;} while (0) #endif #ifndef VI_COMMENT_BEGIN_DEFAULT #define VI_COMMENT_BEGIN_DEFAULT "#" #endif #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* Variables imported from readline.c */ extern int rl_point, rl_end, rl_mark, rl_done; extern FILE *rl_instream; extern int rl_line_buffer_len, rl_explicit_arg, rl_numeric_arg; extern Keymap _rl_keymap; extern char *rl_prompt; extern char *rl_line_buffer; extern int rl_arg_sign; extern void _rl_dispatch (); extern void rl_extend_line_buffer (); extern int rl_vi_check (); /* Non-zero means enter insertion mode. */ static int _rl_vi_doing_insert = 0; /* String inserted into the line by rl_vi_comment (). */ char *rl_vi_comment_begin = (char *)NULL; /* *** UNCLEAN *** */ /* Command keys which do movement for xxx_to commands. */ static char *vi_motion = " hl^$0ftFt;,%wbeWBE|"; /* Keymap used for vi replace characters. Created dynamically since rarely used. */ static Keymap vi_replace_map = (Keymap)NULL; /* The number of characters inserted in the last replace operation. */ static int vi_replace_count = 0; /* If non-zero, we have text inserted after a c[motion] command that put us implicitly into insert mode. Some people want this text to be attached to the command so that it is `redoable' with `.'. */ static int vi_continued_command = 0; static int _rl_vi_last_command = 'i'; /* default `.' puts you in insert mode */ static int _rl_vi_last_repeat = 1; static int _rl_vi_last_arg_sign = 1; static int _rl_vi_last_motion = 0; static int _rl_vi_last_search_char = 0; static int _rl_vi_last_replacement = 0; static int vi_redoing = 0; /* Text modification commands. These are the `redoable' commands. */ static char *vi_textmod = "_*\\AaIiCcDdPpYyRrSsXx~"; static int rl_digit_loop1 (); void _rl_vi_reset_last () { _rl_vi_last_command = 'i'; _rl_vi_last_repeat = 1; _rl_vi_last_arg_sign = 1; _rl_vi_last_motion = 0; } void _rl_vi_set_last (key, repeat, sign) int key, repeat, sign; { _rl_vi_last_command = key; _rl_vi_last_repeat = repeat; _rl_vi_last_arg_sign = sign; } /* Is the command C a VI mode text modification command? */ int rl_vi_textmod_command (c) int c; { return (member (c, vi_textmod)); } /* Bound to `.'. Called from command mode, so we know that we have to redo a text modification command. The default for _rl_vi_last_command puts you back into insert mode. */ rl_vi_redo (count, c) int count, c; { if (!rl_explicit_arg) { rl_numeric_arg = _rl_vi_last_repeat; rl_arg_sign = _rl_vi_last_arg_sign; } vi_redoing = 1; _rl_dispatch (_rl_vi_last_command, _rl_keymap); vi_redoing = 0; return (0); } /* Yank the nth arg from the previous line into this line at point. */ rl_vi_yank_arg (count, key) int count, key; { /* Readline thinks that the first word on a line is the 0th, while vi thinks the first word on a line is the 1st. Compensate. */ if (rl_explicit_arg) rl_yank_nth_arg (count - 1, 0); else rl_yank_nth_arg ('$', 0); return (0); } /* With an argument, move back that many history lines, else move to the beginning of history. */ rl_vi_fetch_history (count, c) int count, c; { int current = where_history (); /* Giving an argument of n means we want the nth command in the history file. The command number is interpreted the same way that the bash `history' command does it -- that is, giving an argument count of 450 to this command would get the command listed as number 450 in the output of `history'. */ if (rl_explicit_arg) { int wanted = history_base + current - count; if (wanted <= 0) rl_beginning_of_history (0, 0); else rl_get_previous_history (wanted); } else rl_beginning_of_history (count, 0); return (0); } /* Search again for the last thing searched for. */ rl_vi_search_again (count, key) int count, key; { switch (key) { case 'n': rl_noninc_reverse_search_again (count, key); break; case 'N': rl_noninc_forward_search_again (count, key); break; } return (0); } /* Do a vi style search. */ rl_vi_search (count, key) int count, key; { switch (key) { case '?': rl_noninc_forward_search (count, key); break; case '/': rl_noninc_reverse_search (count, key); break; default: ding (); break; } return (0); } /* Completion, from vi's point of view. */ rl_vi_complete (ignore, key) int ignore, key; { if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point]))) { if (!whitespace (rl_line_buffer[rl_point + 1])) rl_vi_end_word (1, 'E'); rl_point++; } if (key == '*') rl_complete_internal ('*'); /* Expansion and replacement. */ else if (key == '=') rl_complete_internal ('?'); /* List possible completions. */ else if (key == '\\') rl_complete_internal (TAB); /* Standard Readline completion. */ else rl_complete (0, key); if (key == '*' || key == '\\') { _rl_vi_set_last (key, 1, rl_arg_sign); rl_vi_insertion_mode (); } return (0); } /* Tilde expansion for vi mode. */ rl_vi_tilde_expand (ignore, key) int ignore, key; { rl_tilde_expand (0, key); _rl_vi_set_last (key, 1, rl_arg_sign); /* XXX */ rl_vi_insertion_mode (); return (0); } /* Previous word in vi mode. */ rl_vi_prev_word (count, key) int count, key; { if (count < 0) return (rl_vi_next_word (-count, key)); if (rl_point == 0) { ding (); return (0); } if (uppercase_p (key)) rl_vi_bWord (count); else rl_vi_bword (count); return (0); } /* Next word in vi mode. */ rl_vi_next_word (count, key) int count, key; { if (count < 0) return (rl_vi_prev_word (-count, key)); if (rl_point >= (rl_end - 1)) { ding (); return (0); } if (uppercase_p (key)) rl_vi_fWord (count); else rl_vi_fword (count); return (0); } /* Move to the end of the ?next? word. */ rl_vi_end_word (count, key) int count, key; { if (count < 0) { ding (); return -1; } if (uppercase_p (key)) rl_vi_eWord (count); else rl_vi_eword (count); return (0); } /* Move forward a word the way that 'W' does. */ rl_vi_fWord (count) int count; { while (count-- && rl_point < (rl_end - 1)) { /* Skip until whitespace. */ while (!whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end) rl_point++; /* Now skip whitespace. */ while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end) rl_point++; } return (0); } rl_vi_bWord (count) int count; { while (count-- && rl_point > 0) { /* If we are at the start of a word, move back to whitespace so we will go back to the start of the previous word. */ if (!whitespace (rl_line_buffer[rl_point]) && whitespace (rl_line_buffer[rl_point - 1])) rl_point--; while (rl_point > 0 && whitespace (rl_line_buffer[rl_point])) rl_point--; if (rl_point > 0) { while (--rl_point >= 0 && !whitespace (rl_line_buffer[rl_point])); rl_point++; } } return (0); } rl_vi_eWord (count) int count; { while (count-- && rl_point < (rl_end - 1)) { if (!whitespace (rl_line_buffer[rl_point])) rl_point++; /* Move to the next non-whitespace character (to the start of the next word). */ while (++rl_point < rl_end && whitespace (rl_line_buffer[rl_point])); if (rl_point && rl_point < rl_end) { /* Skip whitespace. */ while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point])) rl_point++; /* Skip until whitespace. */ while (rl_point < rl_end && !whitespace (rl_line_buffer[rl_point])) rl_point++; /* Move back to the last character of the word. */ rl_point--; } } return (0); } rl_vi_fword (count) int count; { while (count-- && rl_point < (rl_end - 1)) { /* Move to white space (really non-identifer). */ if (isident (rl_line_buffer[rl_point])) { while (isident (rl_line_buffer[rl_point]) && rl_point < rl_end) rl_point++; } else /* if (!whitespace (rl_line_buffer[rl_point])) */ { while (!isident (rl_line_buffer[rl_point]) && !whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end) rl_point++; } /* Move past whitespace. */ while (whitespace (rl_line_buffer[rl_point]) && rl_point < rl_end) rl_point++; } return (0); } rl_vi_bword (count) int count; { while (count-- && rl_point > 0) { int last_is_ident; /* If we are at the start of a word, move back to whitespace so we will go back to the start of the previous word. */ if (!whitespace (rl_line_buffer[rl_point]) && whitespace (rl_line_buffer[rl_point - 1])) rl_point--; /* If this character and the previous character are `opposite', move back so we don't get messed up by the rl_point++ down there in the while loop. Without this code, words like `l;' screw up the function. */ last_is_ident = isident (rl_line_buffer[rl_point - 1]); if ((isident (rl_line_buffer[rl_point]) && !last_is_ident) || (!isident (rl_line_buffer[rl_point]) && last_is_ident)) rl_point--; while (rl_point > 0 && whitespace (rl_line_buffer[rl_point])) rl_point--; if (rl_point > 0) { if (isident (rl_line_buffer[rl_point])) while (--rl_point >= 0 && isident (rl_line_buffer[rl_point])); else while (--rl_point >= 0 && !isident (rl_line_buffer[rl_point]) && !whitespace (rl_line_buffer[rl_point])); rl_point++; } } return (0); } rl_vi_eword (count) int count; { while (count-- && rl_point < rl_end - 1) { if (!whitespace (rl_line_buffer[rl_point])) rl_point++; while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point])) rl_point++; if (rl_point < rl_end) { if (isident (rl_line_buffer[rl_point])) while (++rl_point < rl_end && isident (rl_line_buffer[rl_point])); else while (++rl_point < rl_end && !isident (rl_line_buffer[rl_point]) && !whitespace (rl_line_buffer[rl_point])); } rl_point--; } return (0); } rl_vi_insert_beg (count, key) int count, key; { rl_beg_of_line (); rl_vi_insertion_mode (); return (0); } rl_vi_append_mode (count, key) int count, key; { if (rl_point < rl_end) rl_point++; rl_vi_insertion_mode (); return (0); } rl_vi_append_eol (count, key) int count, key; { rl_end_of_line (); rl_vi_append_mode (); return (0); } /* What to do in the case of C-d. */ rl_vi_eof_maybe (count, c) int count, c; { return (rl_newline (1, '\n')); } /* Insertion mode stuff. */ /* Switching from one mode to the other really just involves switching keymaps. */ rl_vi_insertion_mode (count, key) int count, key; { _rl_keymap = vi_insertion_keymap; return (0); } void _rl_vi_done_inserting () { if (_rl_vi_doing_insert) { rl_end_undo_group (); /* Now, the text between rl_undo_list->next->start and rl_undo_list->next->end is what was inserted while in insert mode. */ _rl_vi_doing_insert = 0; vi_continued_command = 1; } else vi_continued_command = 0; } rl_vi_movement_mode (count, key) int count, key; { if (rl_point > 0) rl_backward (1); #if 0 _rl_vi_reset_last (); #endif _rl_keymap = vi_movement_keymap; _rl_vi_done_inserting (); return (0); } rl_vi_arg_digit (count, c) int count, c; { if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg) return (rl_beg_of_line ()); else return (rl_digit_argument (count, c)); } rl_vi_change_case (count, ignore) int count, ignore; { char c = 0; /* Don't try this on an empty line. */ if (rl_point >= rl_end) return (0); while (count-- && rl_point < rl_end) { if (uppercase_p (rl_line_buffer[rl_point])) c = to_lower (rl_line_buffer[rl_point]); else if (lowercase_p (rl_line_buffer[rl_point])) c = to_upper (rl_line_buffer[rl_point]); else { /* Just skip over characters neither upper nor lower case. */ rl_forward (1); continue; } /* Vi is kind of strange here. */ if (c) { rl_begin_undo_group (); rl_delete (1, c); rl_insert (1, c); rl_end_undo_group (); rl_vi_check (); } else rl_forward (1); } return (0); } rl_vi_put (count, key) int count, key; { if (!uppercase_p (key) && (rl_point + 1 <= rl_end)) rl_point++; rl_yank (); rl_backward (1); return (0); } rl_vi_check () { if (rl_point && rl_point == rl_end) rl_point--; return (0); } rl_vi_column (count, key) int count, key; { if (count > rl_end) rl_end_of_line (); else rl_point = count - 1; return (0); } int rl_vi_domove (key, nextkey) int key, *nextkey; { int c, save; int old_end; rl_mark = rl_point; c = rl_read_key (); *nextkey = c; if (!member (c, vi_motion)) { if (digit_p (c)) { save = rl_numeric_arg; rl_numeric_arg = digit_value (c); rl_digit_loop1 (); rl_numeric_arg *= save; c = rl_read_key (); /* real command */ *nextkey = c; } else if (key == c && (key == 'd' || key == 'y' || key == 'c')) { rl_mark = rl_end; rl_beg_of_line (); _rl_vi_last_motion = c; return (0); } else return (-1); } _rl_vi_last_motion = c; /* Append a blank character temporarily so that the motion routines work right at the end of the line. */ old_end = rl_end; rl_line_buffer[rl_end++] = ' '; rl_line_buffer[rl_end] = '\0'; _rl_dispatch (c, _rl_keymap); /* Remove the blank that we added. */ rl_end = old_end; rl_line_buffer[rl_end] = '\0'; if (rl_point > rl_end) rl_point = rl_end; /* No change in position means the command failed. */ if (rl_mark == rl_point) return (-1); /* rl_vi_f[wW]ord () leaves the cursor on the first character of the next word. If we are not at the end of the line, and we are on a non-whitespace character, move back one (presumably to whitespace). */ if ((to_upper (c) == 'W') && rl_point < rl_end && rl_point > rl_mark && !whitespace (rl_line_buffer[rl_point])) rl_point--; /* If cw or cW, back up to the end of a word, so the behaviour of ce or cE is the actual result. Brute-force, no subtlety. */ if (key == 'c' && rl_point >= rl_mark && (to_upper (c) == 'W')) { /* Don't move farther back than where we started. */ while (rl_point > rl_mark && whitespace (rl_line_buffer[rl_point])) rl_point--; /* Posix.2 says that if cw or cW moves the cursor towards the end of the line, the character under the cursor should be deleted. */ if (rl_point == rl_mark) rl_point++; else { /* Move past the end of the word so that the kill doesn't remove the last letter of the previous word. Only do this if we are not at the end of the line. */ if (rl_point >= 0 && rl_point < (rl_end - 1) && !whitespace (rl_line_buffer[rl_point])) rl_point++; } } if (rl_mark < rl_point) exchange (rl_point, rl_mark); return (0); } /* A simplified loop for vi. Don't dispatch key at end. Don't recognize minus sign? */ static int rl_digit_loop1 () { int key, c; while (1) { rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg, 0); key = c = rl_read_key (); if (_rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument) { rl_numeric_arg *= 4; continue; } c = UNMETA (c); if (digit_p (c)) { if (rl_explicit_arg) rl_numeric_arg = (rl_numeric_arg * 10) + digit_value (c); else rl_numeric_arg = digit_value (c); rl_explicit_arg = 1; } else { rl_clear_message (); rl_stuff_char (key); break; } } return (0); } rl_vi_delete_to (count, key) int count, key; { int c; if (uppercase_p (key)) rl_stuff_char ('$'); else if (vi_redoing) rl_stuff_char (_rl_vi_last_motion); if (rl_vi_domove (key, &c)) { ding (); return -1; } /* These are the motion commands that do not require adjusting the mark. */ if ((strchr (" l|h^0%bB", c) == 0) && (rl_mark < rl_end)) rl_mark++; rl_kill_text (rl_point, rl_mark); return (0); } rl_vi_change_to (count, key) int count, key; { int c, start_pos; if (uppercase_p (key)) rl_stuff_char ('$'); else if (vi_redoing) rl_stuff_char (_rl_vi_last_motion); start_pos = rl_point; if (rl_vi_domove (key, &c)) { ding (); return -1; } /* These are the motion commands that do not require adjusting the mark. c[wW] are handled by special-case code in rl_vi_domove(), and already leave the mark at the correct location. */ if ((strchr (" l|hwW^0%bB", c) == 0) && (rl_mark < rl_end)) rl_mark++; /* The cursor never moves with c[wW]. */ if ((to_upper (c) == 'W') && rl_point < start_pos) rl_point = start_pos; rl_kill_text (rl_point, rl_mark); rl_begin_undo_group (); _rl_vi_doing_insert = 1; _rl_vi_set_last (key, count, rl_arg_sign); rl_vi_insertion_mode (); return (0); } rl_vi_yank_to (count, key) int count, key; { int c, save = rl_point; if (uppercase_p (key)) rl_stuff_char ('$'); if (rl_vi_domove (key, &c)) { ding (); return -1; } /* These are the motion commands that do not require adjusting the mark. */ if ((strchr (" l|h^0%bB", c) == 0) && (rl_mark < rl_end)) rl_mark++; rl_begin_undo_group (); rl_kill_text (rl_point, rl_mark); rl_end_undo_group (); rl_do_undo (); rl_point = save; return (0); } rl_vi_delete (count, key) int count, key; { int end; if (rl_end == 0) { ding (); return -1; } end = rl_point + count; if (end >= rl_end) end = rl_end; rl_kill_text (rl_point, end); if (rl_point > 0 && rl_point == rl_end) rl_backward (1); return (0); } /* Turn the current line into a comment in shell history. A K*rn shell style function. */ rl_vi_comment (count, key) int count, key; { rl_beg_of_line (); if (rl_vi_comment_begin != (char *)NULL) rl_insert_text (rl_vi_comment_begin); else rl_insert_text (VI_COMMENT_BEGIN_DEFAULT); /* Default. */ rl_redisplay (); rl_newline (1, '\010'); return (0); } rl_vi_first_print (count, key) int count, key; { return (rl_back_to_indent ()); } rl_back_to_indent (ignore1, ignore2) int ignore1, ignore2; { rl_beg_of_line (); while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point])) rl_point++; return (0); } /* NOTE: it is necessary that opposite directions are inverses */ #define FTO 1 /* forward to */ #define BTO -1 /* backward to */ #define FFIND 2 /* forward find */ #define BFIND -2 /* backward find */ rl_vi_char_search (count, key) int count, key; { static char target; static int orig_dir, dir; int pos; if (key == ';' || key == ',') dir = (key == ';' ? orig_dir : -orig_dir); else { if (vi_redoing) target = _rl_vi_last_search_char; else _rl_vi_last_search_char = target = rl_getc (rl_instream); switch (key) { case 't': orig_dir = dir = FTO; break; case 'T': orig_dir = dir = BTO; break; case 'f': orig_dir = dir = FFIND; break; case 'F': orig_dir = dir = BFIND; break; } } pos = rl_point; while (count--) { if (dir < 0) { if (pos == 0) { ding (); return -1; } pos--; do { if (rl_line_buffer[pos] == target) { if (dir == BTO) rl_point = pos + 1; else rl_point = pos; break; } } while (pos--); if (pos < 0) { ding (); return -1; } } else { /* dir > 0 */ if (pos >= rl_end) { ding (); return -1; } pos++; do { if (rl_line_buffer[pos] == target) { if (dir == FTO) rl_point = pos - 1; else rl_point = pos; break; } } while (++pos < rl_end); if (pos >= (rl_end - 1)) { ding (); return -1; } } } return (0); } /* Match brackets */ rl_vi_match (ignore, key) int ignore, key; { int count = 1, brack, pos; pos = rl_point; if ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0) { while ((brack = rl_vi_bracktype (rl_line_buffer[rl_point])) == 0 && rl_point < rl_end - 1) rl_forward (1); if (brack <= 0) { rl_point = pos; ding (); return -1; } } pos = rl_point; if (brack < 0) { while (count) { if (--pos >= 0) { int b = rl_vi_bracktype (rl_line_buffer[pos]); if (b == -brack) count--; else if (b == brack) count++; } else { ding (); return -1; } } } else { /* brack > 0 */ while (count) { if (++pos < rl_end) { int b = rl_vi_bracktype (rl_line_buffer[pos]); if (b == -brack) count--; else if (b == brack) count++; } else { ding (); return -1; } } } rl_point = pos; return (0); } int rl_vi_bracktype (c) int c; { switch (c) { case '(': return 1; case ')': return -1; case '[': return 2; case ']': return -2; case '{': return 3; case '}': return -3; default: return 0; } } rl_vi_change_char (count, key) int count, key; { int c; if (vi_redoing) c = _rl_vi_last_replacement; else _rl_vi_last_replacement = c = rl_getc (rl_instream); if (c == '\033' || c == CTRL ('C')) return -1; while (count-- && rl_point < rl_end) { rl_begin_undo_group (); rl_delete (1, c); rl_insert (1, c); if (count == 0) rl_backward (1); rl_end_undo_group (); } return (0); } rl_vi_subst (count, key) int count, key; { rl_begin_undo_group (); if (uppercase_p (key)) { rl_beg_of_line (); rl_kill_line (1); } else rl_delete (count, key); rl_end_undo_group (); _rl_vi_set_last (key, count, rl_arg_sign); rl_begin_undo_group (); _rl_vi_doing_insert = 1; rl_vi_insertion_mode (); return (0); } rl_vi_overstrike (count, key) int count, key; { int i; if (_rl_vi_doing_insert == 0) { _rl_vi_doing_insert = 1; rl_begin_undo_group (); } for (i = 0; i < count; i++) { vi_replace_count++; rl_begin_undo_group (); if (rl_point < rl_end) { rl_delete (1, key); rl_insert (1, key); } else rl_insert (1, key); rl_end_undo_group (); } return (0); } rl_vi_overstrike_delete (count) int count; { int i, s; for (i = 0; i < count; i++) { if (vi_replace_count == 0) { ding (); break; } s = rl_point; if (rl_do_undo ()) vi_replace_count--; if (rl_point == s) rl_backward (1); } if (vi_replace_count == 0 && _rl_vi_doing_insert) { rl_end_undo_group (); rl_do_undo (); _rl_vi_doing_insert = 0; } return (0); } rl_vi_replace (count, key) int count, key; { int i; vi_replace_count = 0; if (!vi_replace_map) { vi_replace_map = rl_make_bare_keymap (); for (i = ' '; i < 127; i++) vi_replace_map[i].function = rl_vi_overstrike; vi_replace_map[RUBOUT].function = rl_vi_overstrike_delete; vi_replace_map[ESC].function = rl_vi_movement_mode; vi_replace_map[RETURN].function = rl_newline; vi_replace_map[NEWLINE].function = rl_newline; /* If the normal vi insertion keymap has ^H bound to erase, do the same here. Probably should remove the assignment to RUBOUT up there, but I don't think it will make a difference in real life. */ if (vi_insertion_keymap[CTRL ('H')].type == ISFUNC && vi_insertion_keymap[CTRL ('H')].function == rl_rubout) vi_replace_map[CTRL ('H')].function = rl_vi_overstrike_delete; } _rl_keymap = vi_replace_map; return (0); } #if 0 /* Try to complete the word we are standing on or the word that ends with the previous character. A space matches everything. Word delimiters are space and ;. */ rl_vi_possible_completions() { int save_pos = rl_point; if (rl_line_buffer[rl_point] != ' ' && rl_line_buffer[rl_point] != ';') { while (rl_point < rl_end && rl_line_buffer[rl_point] != ' ' && rl_line_buffer[rl_point] != ';') rl_point++; } else if (rl_line_buffer[rl_point - 1] == ';') { ding (); return (0); } rl_possible_completions (); rl_point = save_pos; return (0); } #endif #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)xmalloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ #endif /* VI_MODE */ lafe/readline/acconfig.h100644 325 24 1720 6106101042 13412 0ustar dlduser/* acconfig.h This file is in the public domain. Descriptive text for the C preprocessor macros that the distributed Autoconf macros can define. No software package will use all of them; autoheader copies the ones your configure.in uses into your configuration header file templates. The entries are in sort -df order: alphabetical, case insensitive, ignoring punctuation (such as underscores). Although this order can split up related entries, it makes it easier to check whether a given entry is in the file. Leave the following blank line there!! Autoheader needs it. */ /* Define if your system defines TIOCGWINSZ in sys/ioctl.h. */ #undef GWINSZ_IN_SYS_IOCTL #undef HAVE_GETPW_DECLS #undef NO_SYS_FILE /* Leave that blank line there!! Autoheader needs it. If you're adding to this file, keep in mind: The entries are in sort -df order: alphabetical, case insensitive, ignoring punctuation (such as underscores). */ lafe/readline/history.c100644 325 24 144610 6106101042 13403 0ustar dlduser/* History.c -- standalone history library */ /* Copyright (C) 1989, 1992 Free Software Foundation, Inc. This file contains the GNU History Library (the Library), a set of routines for managing the text of previously typed lines. The Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* The goal is to make the implementation transparent, so that you don't have to know what data types are used, just what functions you can call. I think I have done that. */ #define READLINE_LIBRARY #if defined (HAVE_CONFIG_H) # include "config.h" #endif #include #include #include #include #include #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #if defined (HAVE_UNISTD_H) # include #endif #if defined (HAVE_STRING_H) # include #else # include #endif /* !HAVE_STRING_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include "memalloc.h" #include "history.h" #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ #define STREQ(a, b) (((a)[0] == (b)[0]) && (strcmp ((a), (b)) == 0)) #define STREQN(a, b, n) (((a)[0] == (b)[0]) && (strncmp ((a), (b), (n)) == 0)) #ifndef savestring # ifndef strcpy extern char *strcpy (); # endif #define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x)) #endif #ifndef whitespace #define whitespace(c) (((c) == ' ') || ((c) == '\t')) #endif #ifndef digit_p #define digit_p(c) ((c) >= '0' && (c) <= '9') #endif #ifndef digit_value #define digit_value(c) ((c) - '0') #endif #ifndef member # ifndef strchr extern char *strchr (); # endif #define member(c, s) ((c) ? ((char *)strchr ((s), (c)) != (char *)NULL) : 0) #endif /* Possible history errors passed to hist_error. */ #define EVENT_NOT_FOUND 0 #define BAD_WORD_SPEC 1 #define SUBST_FAILED 2 #define BAD_MODIFIER 3 static char error_pointer; static char *subst_lhs; static char *subst_rhs; static int subst_lhs_len = 0; static int subst_rhs_len = 0; static char *get_history_word_specifier (); #if defined (SHELL) extern char *single_quote (); #endif /* **************************************************************** */ /* */ /* History Functions */ /* */ /* **************************************************************** */ /* An array of HIST_ENTRY. This is where we store the history. */ static HIST_ENTRY **the_history = (HIST_ENTRY **)NULL; /* Non-zero means that we have enforced a limit on the amount of history that we save. */ static int history_stifled = 0; /* If HISTORY_STIFLED is non-zero, then this is the maximum number of entries to remember. */ int max_input_history; /* The current location of the interactive history pointer. Just makes life easier for outside callers. */ static int history_offset = 0; /* The number of strings currently stored in the input_history list. */ int history_length = 0; /* The current number of slots allocated to the input_history. */ static int history_size = 0; /* The number of slots to increase the_history by. */ #define DEFAULT_HISTORY_GROW_SIZE 50 /* The character that represents the start of a history expansion request. This is usually `!'. */ char history_expansion_char = '!'; /* The character that invokes word substitution if found at the start of a line. This is usually `^'. */ char history_subst_char = '^'; /* During tokenization, if this character is seen as the first character of a word, then it, and all subsequent characters upto a newline are ignored. For a Bourne shell, this should be '#'. Bash special cases the interactive comment character to not be a comment delimiter. */ char history_comment_char = '\0'; /* The list of characters which inhibit the expansion of text if found immediately following history_expansion_char. */ char *history_no_expand_chars = " \t\n\r="; /* The logical `base' of the history array. It defaults to 1. */ int history_base = 1; /* Return the current HISTORY_STATE of the history. */ HISTORY_STATE * history_get_history_state () { HISTORY_STATE *state; state = (HISTORY_STATE *)xmalloc (sizeof (HISTORY_STATE)); state->entries = the_history; state->offset = history_offset; state->length = history_length; state->size = history_size; state->flags = 0; if (history_stifled) state->flags |= HS_STIFLED; return (state); } /* Set the state of the current history array to STATE. */ void history_set_history_state (state) HISTORY_STATE *state; { the_history = state->entries; history_offset = state->offset; history_length = state->length; history_size = state->size; if (state->flags & HS_STIFLED) history_stifled = 1; } /* Begin a session in which the history functions might be used. This initializes interactive variables. */ void using_history () { history_offset = history_length; } /* Return the number of bytes that the primary history entries are using. This just adds up the lengths of the_history->lines. */ int history_total_bytes () { register int i, result; result = 0; for (i = 0; the_history && the_history[i]; i++) result += strlen (the_history[i]->line); return (result); } /* Place STRING at the end of the history list. The data field is set to NULL. */ void add_history (string) char *string; { HIST_ENTRY *temp; if (history_stifled && (history_length == max_input_history)) { register int i; /* If the history is stifled, and history_length is zero, and it equals max_input_history, we don't save items. */ if (history_length == 0) return; /* If there is something in the slot, then remove it. */ if (the_history[0]) { free (the_history[0]->line); free (the_history[0]); } /* Copy the rest of the entries, moving down one slot. */ for (i = 0; i < history_length; i++) the_history[i] = the_history[i + 1]; history_base++; } else { if (!history_size) { history_size = DEFAULT_HISTORY_GROW_SIZE; the_history = (HIST_ENTRY **)xmalloc (history_size * sizeof (HIST_ENTRY *)); history_length = 1; } else { if (history_length == (history_size - 1)) { history_size += DEFAULT_HISTORY_GROW_SIZE; the_history = (HIST_ENTRY **) xrealloc (the_history, history_size * sizeof (HIST_ENTRY *)); } history_length++; } } temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); temp->line = savestring (string); temp->data = (char *)NULL; the_history[history_length] = (HIST_ENTRY *)NULL; the_history[history_length - 1] = temp; } /* Make the history entry at WHICH have LINE and DATA. This returns the old entry so you can dispose of the data. In the case of an invalid WHICH, a NULL pointer is returned. */ HIST_ENTRY * replace_history_entry (which, line, data) int which; char *line; char *data; { HIST_ENTRY *temp = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); HIST_ENTRY *old_value; if (which >= history_length) return ((HIST_ENTRY *)NULL); old_value = the_history[which]; temp->line = savestring (line); temp->data = data; the_history[which] = temp; return (old_value); } /* Returns the magic number which says what history element we are looking at now. In this implementation, it returns history_offset. */ int where_history () { return (history_offset); } /* Search the history for STRING, starting at history_offset. If DIRECTION < 0, then the search is through previous entries, else through subsequent. If ANCHORED is non-zero, the string must appear at the beginning of a history line, otherwise, the string may appear anywhere in the line. If the string is found, then current_history () is the history entry, and the value of this function is the offset in the line of that history entry that the string was found in. Otherwise, nothing is changed, and a -1 is returned. */ #define ANCHORED_SEARCH 1 #define NON_ANCHORED_SEARCH 0 static int history_search_internal (string, direction, anchored) char *string; int direction, anchored; { register int i, reverse; register char *line; register int line_index; int string_len; i = history_offset; reverse = (direction < 0); /* Take care of trivial cases first. */ if (!history_length || ((i == history_length) && !reverse)) return (-1); if (reverse && (i == history_length)) i--; #define NEXT_LINE() do { if (reverse) i--; else i++; } while (0) string_len = strlen (string); while (1) { /* Search each line in the history list for STRING. */ /* At limit for direction? */ if ((reverse && i < 0) || (!reverse && i == history_length)) return (-1); line = the_history[i]->line; line_index = strlen (line); /* If STRING is longer than line, no match. */ if (string_len > line_index) { NEXT_LINE (); continue; } /* Handle anchored searches first. */ if (anchored == ANCHORED_SEARCH) { if (STREQN (string, line, string_len)) { history_offset = i; return (0); } NEXT_LINE (); continue; } /* Do substring search. */ if (reverse) { line_index -= string_len; while (line_index >= 0) { if (STREQN (string, line + line_index, string_len)) { history_offset = i; return (line_index); } line_index--; } } else { register int limit = line_index - string_len + 1; line_index = 0; while (line_index < limit) { if (STREQN (string, line + line_index, string_len)) { history_offset = i; return (line_index); } line_index++; } } NEXT_LINE (); } } /* Do a non-anchored search for STRING through the history in DIRECTION. */ int history_search (string, direction) char *string; int direction; { return (history_search_internal (string, direction, NON_ANCHORED_SEARCH)); } /* Do an anchored search for string through the history in DIRECTION. */ int history_search_prefix (string, direction) char *string; int direction; { return (history_search_internal (string, direction, ANCHORED_SEARCH)); } /* Remove history element WHICH from the history. The removed element is returned to you so you can free the line, data, and containing structure. */ HIST_ENTRY * remove_history (which) int which; { HIST_ENTRY *return_value; if (which >= history_length || !history_length) return_value = (HIST_ENTRY *)NULL; else { register int i; return_value = the_history[which]; for (i = which; i < history_length; i++) the_history[i] = the_history[i + 1]; history_length--; } return (return_value); } /* Stifle the history list, remembering only MAX number of lines. */ void stifle_history (max) int max; { if (max < 0) max = 0; if (history_length > max) { register int i, j; /* This loses because we cannot free the data. */ for (i = 0; i < (history_length - max); i++) { free (the_history[i]->line); free (the_history[i]); } history_base = i; for (j = 0, i = history_length - max; j < max; i++, j++) the_history[j] = the_history[i]; the_history[j] = (HIST_ENTRY *)NULL; history_length = j; } history_stifled = 1; max_input_history = max; } /* Stop stifling the history. This returns the previous amount the history was stifled by. The value is positive if the history was stifled, negative if it wasn't. */ int unstifle_history () { int result = max_input_history; if (history_stifled) { result = -result; history_stifled = 0; } return (result); } int history_is_stifled () { return (history_stifled); } /* Return the string that should be used in the place of this filename. This only matters when you don't specify the filename to read_history (), or write_history (). */ static char * history_filename (filename) char *filename; { char *return_val = filename ? savestring (filename) : (char *)NULL; if (!return_val) { char *home; int home_len; home = getenv ("HOME"); if (!home) home = "."; home_len = strlen (home); /* strlen(".history") == 8 */ return_val = xmalloc (2 + home_len + 8); strcpy (return_val, home); return_val[home_len] = '/'; strcpy (return_val + home_len + 1, ".history"); } return (return_val); } /* Add the contents of FILENAME to the history list, a line at a time. If FILENAME is NULL, then read from ~/.history. Returns 0 if successful, or errno if not. */ int read_history (filename) char *filename; { return (read_history_range (filename, 0, -1)); } /* Read a range of lines from FILENAME, adding them to the history list. Start reading at the FROM'th line and end at the TO'th. If FROM is zero, start at the beginning. If TO is less than FROM, read until the end of the file. If FILENAME is NULL, then read from ~/.history. Returns 0 if successful, or errno if not. */ int read_history_range (filename, from, to) char *filename; int from, to; { register int line_start, line_end; char *input, *buffer = (char *)NULL; int file, current_line; struct stat finfo; input = history_filename (filename); file = open (input, O_RDONLY, 0666); if ((file < 0) || (fstat (file, &finfo) == -1)) goto error_and_exit; buffer = xmalloc ((int)finfo.st_size + 1); if (read (file, buffer, finfo.st_size) != finfo.st_size) { error_and_exit: if (file >= 0) close (file); if (input) free (input); if (buffer) free (buffer); return (errno); } close (file); /* Set TO to larger than end of file if negative. */ if (to < 0) to = finfo.st_size; /* Start at beginning of file, work to end. */ line_start = line_end = current_line = 0; /* Skip lines until we are at FROM. */ while (line_start < finfo.st_size && current_line < from) { for (line_end = line_start; line_end < finfo.st_size; line_end++) if (buffer[line_end] == '\n') { current_line++; line_start = line_end + 1; if (current_line == from) break; } } /* If there are lines left to gobble, then gobble them now. */ for (line_end = line_start; line_end < finfo.st_size; line_end++) if (buffer[line_end] == '\n') { buffer[line_end] = '\0'; if (buffer[line_start]) add_history (buffer + line_start); current_line++; if (current_line >= to) break; line_start = line_end + 1; } if (input) free (input); if (buffer) free (buffer); return (0); } /* Truncate the history file FNAME, leaving only LINES trailing lines. If FNAME is NULL, then use ~/.history. */ int history_truncate_file (fname, lines) char *fname; register int lines; { register int i; int file, chars_read; char *buffer = (char *)NULL, *filename; struct stat finfo; filename = history_filename (fname); file = open (filename, O_RDONLY, 0666); if (file == -1 || fstat (file, &finfo) == -1) goto truncate_exit; buffer = xmalloc ((int)finfo.st_size + 1); chars_read = read (file, buffer, finfo.st_size); close (file); if (chars_read <= 0) goto truncate_exit; /* Count backwards from the end of buffer until we have passed LINES lines. */ for (i = chars_read - 1; lines && i; i--) { if (buffer[i] == '\n') lines--; } /* If this is the first line, then the file contains exactly the number of lines we want to truncate to, so we don't need to do anything. It's the first line if we don't find a newline between the current value of i and 0. Otherwise, write from the start of this line until the end of the buffer. */ for ( ; i; i--) if (buffer[i] == '\n') { i++; break; } /* Write only if there are more lines in the file than we want to truncate to. */ if (i && ((file = open (filename, O_WRONLY|O_TRUNC, 0666)) != -1)) { write (file, buffer + i, finfo.st_size - i); close (file); } truncate_exit: if (buffer) free (buffer); free (filename); return 0; } #define HISTORY_APPEND 0 #define HISTORY_OVERWRITE 1 /* Workhorse function for writing history. Writes NELEMENT entries from the history list to FILENAME. OVERWRITE is non-zero if you wish to replace FILENAME with the entries. */ static int history_do_write (filename, nelements, overwrite) char *filename; int nelements, overwrite; { register int i; char *output = history_filename (filename); int file, mode; mode = overwrite ? O_WRONLY | O_CREAT | O_TRUNC : O_WRONLY | O_APPEND; if ((file = open (output, mode, 0666)) == -1) { if (output) free (output); return (errno); } if (nelements > history_length) nelements = history_length; /* Build a buffer of all the lines to write, and write them in one syscall. Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */ { register int j = 0; int buffer_size = 0; char *buffer; /* Calculate the total number of bytes to write. */ for (i = history_length - nelements; i < history_length; i++) buffer_size += 1 + strlen (the_history[i]->line); /* Allocate the buffer, and fill it. */ buffer = xmalloc (buffer_size); for (i = history_length - nelements; i < history_length; i++) { strcpy (buffer + j, the_history[i]->line); j += strlen (the_history[i]->line); buffer[j++] = '\n'; } write (file, buffer, buffer_size); free (buffer); } close (file); if (output) free (output); return (0); } /* Append NELEMENT entries to FILENAME. The entries appended are from the end of the list minus NELEMENTs up to the end of the list. */ int append_history (nelements, filename) int nelements; char *filename; { return (history_do_write (filename, nelements, HISTORY_APPEND)); } /* Overwrite FILENAME with the current history. If FILENAME is NULL, then write the history list to ~/.history. Values returned are as in read_history ().*/ int write_history (filename) char *filename; { return (history_do_write (filename, history_length, HISTORY_OVERWRITE)); } /* Return the history entry at the current position, as determined by history_offset. If there is no entry there, return a NULL pointer. */ HIST_ENTRY * current_history () { if ((history_offset == history_length) || !the_history) return ((HIST_ENTRY *)NULL); else return (the_history[history_offset]); } /* Back up history_offset to the previous history entry, and return a pointer to that entry. If there is no previous entry then return a NULL pointer. */ HIST_ENTRY * previous_history () { if (!history_offset) return ((HIST_ENTRY *)NULL); else return (the_history[--history_offset]); } /* Move history_offset forward to the next history entry, and return a pointer to that entry. If there is no next entry then return a NULL pointer. */ HIST_ENTRY * next_history () { if (history_offset == history_length) return ((HIST_ENTRY *)NULL); else return (the_history[++history_offset]); } /* Return the current history array. The caller has to be carefull, since this is the actual array of data, and could be bashed or made corrupt easily. The array is terminated with a NULL pointer. */ HIST_ENTRY ** history_list () { return (the_history); } /* Return the history entry which is logically at OFFSET in the history array. OFFSET is relative to history_base. */ HIST_ENTRY * history_get (offset) int offset; { int local_index = offset - history_base; if (local_index >= history_length || local_index < 0 || !the_history) return ((HIST_ENTRY *)NULL); return (the_history[local_index]); } /* Search for STRING in the history list. DIR is < 0 for searching backwards. POS is an absolute index into the history list at which point to begin searching. */ int history_search_pos (string, dir, pos) char *string; int dir, pos; { int ret, old = where_history (); history_set_pos (pos); if (history_search (string, dir) == -1) { history_set_pos (old); return (-1); } ret = where_history (); history_set_pos (old); return ret; } /* Make the current history item be the one at POS, an absolute index. Returns zero if POS is out of range, else non-zero. */ int history_set_pos (pos) int pos; { if (pos > history_length || pos < 0 || !the_history) return (0); history_offset = pos; return (1); } /* **************************************************************** */ /* */ /* History Expansion */ /* */ /* **************************************************************** */ /* Hairy history expansion on text, not tokens. This is of general use, and thus belongs in this library. */ /* The last string searched for in a !?string? search. */ static char *search_string = (char *)NULL; /* Return the event specified at TEXT + OFFSET modifying OFFSET to point to after the event specifier. Just a pointer to the history line is returned; NULL is returned in the event of a bad specifier. You pass STRING with *INDEX equal to the history_expansion_char that begins this specification. DELIMITING_QUOTE is a character that is allowed to end the string specification for what to search for in addition to the normal characters `:', ` ', `\t', `\n', and sometimes `?'. So you might call this function like: line = get_history_event ("!echo:p", &index, 0); */ char * get_history_event (string, caller_index, delimiting_quote) char *string; int *caller_index; int delimiting_quote; { register int i = *caller_index; register char c; HIST_ENTRY *entry; int which, sign = 1; int local_index, search_mode, substring_okay = 0; char *temp; /* The event can be specified in a number of ways. !! the previous command !n command line N !-n current command-line minus N !str the most recent command starting with STR !?str[?] the most recent command containing STR All values N are determined via HISTORY_BASE. */ if (string[i] != history_expansion_char) return ((char *)NULL); /* Move on to the specification. */ i++; #define RETURN_ENTRY(e, w) \ return ((e = history_get (w)) ? e->line : (char *)NULL) /* Handle !! case. */ if (string[i] == history_expansion_char) { i++; which = history_base + (history_length - 1); *caller_index = i; RETURN_ENTRY (entry, which); } /* Hack case of numeric line specification. */ if (string[i] == '-') { sign = -1; i++; } if (digit_p (string[i])) { /* Get the extent of the digits and compute the value. */ for (which = 0; digit_p (string[i]); i++) which = (which * 10) + digit_value (string[i]); *caller_index = i; if (sign < 0) which = (history_length + history_base) - which; RETURN_ENTRY (entry, which); } /* This must be something to search for. If the spec begins with a '?', then the string may be anywhere on the line. Otherwise, the string must be found at the start of a line. */ if (string[i] == '?') { substring_okay++; i++; } /* Only a closing `?' or a newline delimit a substring search string. */ for (local_index = i; c = string[i]; i++) if ((!substring_okay && (whitespace (c) || c == ':' || #if defined (SHELL) member (c, ";&()|<>") || #endif /* SHELL */ string[i] == delimiting_quote)) || string[i] == '\n' || (substring_okay && string[i] == '?')) break; temp = xmalloc (1 + (i - local_index)); strncpy (temp, &string[local_index], (i - local_index)); temp[i - local_index] = '\0'; if (substring_okay && string[i] == '?') i++; *caller_index = i; #define FAIL_SEARCH() \ do { history_offset = history_length; free (temp) ; return (char *)NULL; } while (0) search_mode = substring_okay ? NON_ANCHORED_SEARCH : ANCHORED_SEARCH; while (1) { local_index = history_search_internal (temp, -1, search_mode); if (local_index < 0) FAIL_SEARCH (); if (local_index == 0 || substring_okay) { entry = current_history (); history_offset = history_length; /* If this was a substring search, then remember the string that we matched for word substitution. */ if (substring_okay) { if (search_string) free (search_string); search_string = temp; } else free (temp); return (entry->line); } if (history_offset) history_offset--; else FAIL_SEARCH (); } #undef FAIL_SEARCH #undef RETURN_ENTRY } #if defined (SHELL) /* Function for extracting single-quoted strings. Used for inhibiting history expansion within single quotes. */ /* Extract the contents of STRING as if it is enclosed in single quotes. SINDEX, when passed in, is the offset of the character immediately following the opening single quote; on exit, SINDEX is left pointing to the closing single quote. */ static void rl_string_extract_single_quoted (string, sindex) char *string; int *sindex; { register int i = *sindex; while (string[i] && string[i] != '\'') i++; *sindex = i; } static char * quote_breaks (s) char *s; { register char *p, *r; char *ret; int len = 3; for (p = s; p && *p; p++, len++) { if (*p == '\'') len += 3; else if (whitespace (*p) || *p == '\n') len += 2; } r = ret = xmalloc (len); *r++ = '\''; for (p = s; p && *p; ) { if (*p == '\'') { *r++ = '\''; *r++ = '\\'; *r++ = '\''; *r++ = '\''; p++; } else if (whitespace (*p) || *p == '\n') { *r++ = '\''; *r++ = *p++; *r++ = '\''; } else *r++ = *p++; } *r++ = '\''; *r = '\0'; return ret; } #endif /* SHELL */ static char * hist_error(s, start, current, errtype) char *s; int start, current, errtype; { char *temp, *emsg; int ll, elen; ll = current - start; switch (errtype) { case EVENT_NOT_FOUND: emsg = "event not found"; elen = 15; break; case BAD_WORD_SPEC: emsg = "bad word specifier"; elen = 18; break; case SUBST_FAILED: emsg = "substitution failed"; elen = 19; break; case BAD_MODIFIER: emsg = "unrecognized history modifier"; elen = 29; break; default: emsg = "unknown expansion error"; elen = 23; break; } temp = xmalloc (ll + elen + 3); strncpy (temp, s + start, ll); temp[ll] = ':'; temp[ll + 1] = ' '; strcpy (temp + ll + 2, emsg); return (temp); } /* Get a history substitution string from STR starting at *IPTR and return it. The length is returned in LENPTR. A backslash can quote the delimiter. If the string is the empty string, the previous pattern is used. If there is no previous pattern for the lhs, the last history search string is used. If IS_RHS is 1, we ignore empty strings and set the pattern to "" anyway. subst_lhs is not changed if the lhs is empty; subst_rhs is allowed to be set to the empty string. */ static char * get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr) char *str; int *iptr, delimiter, is_rhs, *lenptr; { register int si, i, j, k; char *s = (char *) NULL; i = *iptr; for (si = i; str[si] && str[si] != delimiter; si++) if (str[si] == '\\' && str[si + 1] == delimiter) si++; if (si > i || is_rhs) { s = xmalloc (si - i + 1); for (j = 0, k = i; k < si; j++, k++) { /* Remove a backslash quoting the search string delimiter. */ if (str[k] == '\\' && str[k + 1] == delimiter) k++; s[j] = str[k]; } s[j] = '\0'; if (lenptr) *lenptr = j; } i = si; if (str[i]) i++; *iptr = i; return s; } static void postproc_subst_rhs () { char *new; int i, j, new_size; new = xmalloc (new_size = subst_rhs_len + subst_lhs_len); for (i = j = 0; i < subst_rhs_len; i++) { if (subst_rhs[i] == '&') { if (j + subst_lhs_len >= new_size) new = xrealloc (new, (new_size = new_size * 2 + subst_lhs_len)); strcpy (new + j, subst_lhs); j += subst_lhs_len; } else { /* a single backslash protects the `&' from lhs interpolation */ if (subst_rhs[i] == '\\' && subst_rhs[i + 1] == '&') i++; if (j >= new_size) new = xrealloc (new, new_size *= 2); new[j++] = subst_rhs[i]; } } new[j] = '\0'; free (subst_rhs); subst_rhs = new; subst_rhs_len = j; } /* Expand the bulk of a history specifier starting at STRING[START]. Returns 0 if everything is OK, -1 if an error occurred, and 1 if the `p' modifier was supplied and the caller should just print the returned string. Returns the new index into string in *END_INDEX_PTR, and the expanded specifier in *RET_STRING. */ static int history_expand_internal (string, start, end_index_ptr, ret_string, current_line) char *string; int start, *end_index_ptr; char **ret_string; char *current_line; /* for !# */ { int i, n, starting_index; int substitute_globally, want_quotes, print_only; char *event, *temp, *result, *tstr, *t, c, *word_spec; int result_len; result = xmalloc (result_len = 128); i = start; /* If it is followed by something that starts a word specifier, then !! is implied as the event specifier. */ if (member (string[i + 1], ":$*%^")) { char fake_s[3]; int fake_i = 0; i++; fake_s[0] = fake_s[1] = history_expansion_char; fake_s[2] = '\0'; event = get_history_event (fake_s, &fake_i, 0); } else if (string[i + 1] == '#') { i += 2; event = current_line; } else { int quoted_search_delimiter = 0; /* If the character before this `!' is a double or single quote, then this expansion takes place inside of the quoted string. If we have to search for some text ("!foo"), allow the delimiter to end the search string. */ if (i && (string[i - 1] == '\'' || string[i - 1] == '"')) quoted_search_delimiter = string[i - 1]; event = get_history_event (string, &i, quoted_search_delimiter); } if (!event) { *ret_string = hist_error (string, start, i, EVENT_NOT_FOUND); free (result); return (-1); } /* If a word specifier is found, then do what that requires. */ starting_index = i; word_spec = get_history_word_specifier (string, event, &i); /* There is no such thing as a `malformed word specifier'. However, it is possible for a specifier that has no match. In that case, we complain. */ if (word_spec == (char *)&error_pointer) { *ret_string = hist_error (string, starting_index, i, BAD_WORD_SPEC); free (result); return (-1); } /* If no word specifier, than the thing of interest was the event. */ if (!word_spec) temp = savestring (event); else { temp = savestring (word_spec); free (word_spec); } /* Perhaps there are other modifiers involved. Do what they say. */ want_quotes = substitute_globally = print_only = 0; starting_index = i; while (string[i] == ':') { c = string[i + 1]; if (c == 'g') { substitute_globally = 1; i++; c = string[i + 1]; } switch (c) { default: *ret_string = hist_error (string, i+1, i+2, BAD_MODIFIER); free (result); free (temp); return -1; #if defined (SHELL) case 'q': want_quotes = 'q'; break; case 'x': want_quotes = 'x'; break; #endif /* SHELL */ /* :p means make this the last executed line. So we return an error state after adding this line to the history. */ case 'p': print_only++; break; /* :t discards all but the last part of the pathname. */ case 't': tstr = strrchr (temp, '/'); if (tstr) { tstr++; t = savestring (tstr); free (temp); temp = t; } break; /* :h discards the last part of a pathname. */ case 'h': tstr = strrchr (temp, '/'); if (tstr) *tstr = '\0'; break; /* :r discards the suffix. */ case 'r': tstr = strrchr (temp, '.'); if (tstr) *tstr = '\0'; break; /* :e discards everything but the suffix. */ case 'e': tstr = strrchr (temp, '.'); if (tstr) { t = savestring (tstr); free (temp); temp = t; } break; /* :s/this/that substitutes `that' for the first occurrence of `this'. :gs/this/that substitutes `that' for each occurrence of `this'. :& repeats the last substitution. :g& repeats the last substitution globally. */ case '&': case 's': { char *new_event, *t; int delimiter, failed, si, l_temp; if (c == 's') { if (i + 2 < (int)strlen (string)) delimiter = string[i + 2]; else break; /* no search delimiter */ i += 3; t = get_subst_pattern (string, &i, delimiter, 0, &subst_lhs_len); /* An empty substitution lhs with no previous substitution uses the last search string as the lhs. */ if (t) { if (subst_lhs) free (subst_lhs); subst_lhs = t; } else if (!subst_lhs) { if (search_string && *search_string) { subst_lhs = savestring (search_string); subst_lhs_len = strlen (subst_lhs); } else { subst_lhs = (char *) NULL; subst_lhs_len = 0; } } /* If there is no lhs, the substitution can't succeed. */ if (subst_lhs_len == 0) { *ret_string = hist_error (string, starting_index, i, SUBST_FAILED); free (result); free (temp); return -1; } if (subst_rhs) free (subst_rhs); subst_rhs = get_subst_pattern (string, &i, delimiter, 1, &subst_rhs_len); /* If `&' appears in the rhs, it's supposed to be replaced with the lhs. */ if (member ('&', subst_rhs)) postproc_subst_rhs (); } else i += 2; l_temp = strlen (temp); /* Ignore impossible cases. */ if (subst_lhs_len > l_temp) { *ret_string = hist_error (string, starting_index, i, SUBST_FAILED); free (result); free (temp); return (-1); } /* Find the first occurrence of THIS in TEMP. */ si = 0; for (failed = 1; (si + subst_lhs_len) <= l_temp; si++) if (STREQN (temp+si, subst_lhs, subst_lhs_len)) { int len = subst_rhs_len - subst_lhs_len + l_temp; new_event = xmalloc (1 + len); strncpy (new_event, temp, si); strncpy (new_event + si, subst_rhs, subst_rhs_len); strncpy (new_event + si + subst_rhs_len, temp + si + subst_lhs_len, l_temp - (si + subst_lhs_len)); new_event[len] = '\0'; free (temp); temp = new_event; failed = 0; if (substitute_globally) { si += subst_rhs_len; l_temp = strlen (temp); substitute_globally++; continue; } else break; } if (substitute_globally > 1) { substitute_globally = 0; continue; /* don't want to increment i */ } if (failed == 0) continue; /* don't want to increment i */ *ret_string = hist_error (string, starting_index, i, SUBST_FAILED); free (result); free (temp); return (-1); } } i += 2; } /* Done with modfiers. */ /* Believe it or not, we have to back the pointer up by one. */ --i; #if defined (SHELL) if (want_quotes) { char *x; if (want_quotes == 'q') x = single_quote (temp); else if (want_quotes == 'x') x = quote_breaks (temp); else x = savestring (temp); free (temp); temp = x; } #endif /* SHELL */ n = strlen (temp); if (n > result_len) result = xrealloc (result, n + 2); strcpy (result, temp); free (temp); *end_index_ptr = i; *ret_string = result; return (print_only); } /* Expand the string STRING, placing the result into OUTPUT, a pointer to a string. Returns: -1) If there was an error in expansion. 0) If no expansions took place (or, if the only change in the text was the de-slashifying of the history expansion character) 1) If expansions did take place 2) If the `p' modifier was given and the caller should print the result If an error ocurred in expansion, then OUTPUT contains a descriptive error message. */ #define ADD_STRING(s) \ do \ { \ int sl = strlen (s); \ j += sl; \ if (j >= result_len) \ { \ while (j >= result_len) \ result_len += 128; \ result = xrealloc (result, result_len); \ } \ strcpy (result + j - sl, s); \ } \ while (0) #define ADD_CHAR(c) \ do \ { \ if (j >= result_len - 1) \ result = xrealloc (result, result_len += 64); \ result[j++] = c; \ result[j] = '\0'; \ } \ while (0) int history_expand (hstring, output) char *hstring; char **output; { register int j; int i, r, l, passc, cc, modified, eindex, only_printing; char *string; /* The output string, and its length. */ int result_len; char *result; /* Used when adding the string. */ char *temp; /* Setting the history expansion character to 0 inhibits all history expansion. */ if (history_expansion_char == 0) { *output = savestring (hstring); return (0); } /* Prepare the buffer for printing error messages. */ result = xmalloc (result_len = 256); result[0] = '\0'; only_printing = modified = 0; l = strlen (hstring); /* Grovel the string. Only backslash can quote the history escape character. We also handle arg specifiers. */ /* Before we grovel forever, see if the history_expansion_char appears anywhere within the text. */ /* The quick substitution character is a history expansion all right. That is to say, "^this^that^" is equivalent to "!!:s^this^that^", and in fact, that is the substitution that we do. */ if (hstring[0] == history_subst_char) { string = xmalloc (l + 5); string[0] = string[1] = history_expansion_char; string[2] = ':'; string[3] = 's'; strcpy (string + 4, hstring); l += 4; } else { string = hstring; /* If not quick substitution, still maybe have to do expansion. */ /* `!' followed by one of the characters in history_no_expand_chars is NOT an expansion. */ for (i = 0; string[i]; i++) { cc = string[i + 1]; if (string[i] == history_expansion_char) { if (!cc || member (cc, history_no_expand_chars)) continue; #if defined (SHELL) /* The shell uses ! as a pattern negation character in globbing [...] expressions, so let those pass without expansion. */ else if (i > 0 && (string[i - 1] == '[') && member (']', string + i + 1)) continue; #endif /* SHELL */ else break; } #if defined (SHELL) else if (string[i] == '\'') { /* If this is bash, single quotes inhibit history expansion. */ i++; rl_string_extract_single_quoted (string, &i); } else if (string[i] == '\\') { /* If this is bash, allow backslashes to quote single quotes and the history expansion character. */ if (cc == '\'' || cc == history_expansion_char) i++; } #endif /* SHELL */ } if (string[i] != history_expansion_char) { free (result); *output = savestring (string); return (0); } } /* Extract and perform the substitution. */ for (passc = i = j = 0; i < l; i++) { int tchar = string[i]; if (passc) { passc = 0; ADD_CHAR (tchar); continue; } if (tchar == history_expansion_char) tchar = -3; switch (tchar) { default: ADD_CHAR (string[i]); break; case '\\': passc++; ADD_CHAR (tchar); break; #if defined (SHELL) case '\'': { /* If this is bash, single quotes inhibit history expansion. */ int quote, slen; quote = i++; rl_string_extract_single_quoted (string, &i); slen = i - quote + 2; temp = xmalloc (slen); strncpy (temp, string + quote, slen); temp[slen - 1] = '\0'; ADD_STRING (temp); free (temp); break; } #endif /* SHELL */ case -3: /* history_expansion_char */ cc = string[i + 1]; /* If the history_expansion_char is followed by one of the characters in history_no_expand_chars, then it is not a candidate for expansion of any kind. */ if (member (cc, history_no_expand_chars)) { ADD_CHAR (string[i]); break; } #if defined (NO_BANG_HASH_MODIFIERS) /* There is something that is listed as a `word specifier' in csh documentation which means `the expanded text to this point'. That is not a word specifier, it is an event specifier. If we don't want to allow modifiers with `!#', just stick the current output line in again. */ if (cc == '#') { if (result) { temp = xmalloc (1 + strlen (result)); strcpy (temp, result); ADD_STRING (temp); free (temp); } i++; break; } #endif r = history_expand_internal (string, i, &eindex, &temp, result); if (r < 0) { *output = temp; free (result); if (string != hstring) free (string); return -1; } else { if (temp) { modified++; if (*temp) ADD_STRING (temp); free (temp); } only_printing = r == 1; i = eindex; } break; } } *output = result; if (string != hstring) free (string); if (only_printing) { add_history (result); return (2); } return (modified != 0); } /* Return a consed string which is the word specified in SPEC, and found in FROM. NULL is returned if there is no spec. The address of ERROR_POINTER is returned if the word specified cannot be found. CALLER_INDEX is the offset in SPEC to start looking; it is updated to point to just after the last character parsed. */ static char * get_history_word_specifier (spec, from, caller_index) char *spec, *from; int *caller_index; { register int i = *caller_index; int first, last; int expecting_word_spec = 0; char *result; /* The range of words to return doesn't exist yet. */ first = last = 0; result = (char *)NULL; /* If we found a colon, then this *must* be a word specification. If it isn't, then it is an error. */ if (spec[i] == ':') { i++; expecting_word_spec++; } /* Handle special cases first. */ /* `%' is the word last searched for. */ if (spec[i] == '%') { *caller_index = i + 1; return (search_string ? savestring (search_string) : savestring ("")); } /* `*' matches all of the arguments, but not the command. */ if (spec[i] == '*') { *caller_index = i + 1; result = history_arg_extract (1, '$', from); return (result ? result : savestring ("")); } /* `$' is last arg. */ if (spec[i] == '$') { *caller_index = i + 1; return (history_arg_extract ('$', '$', from)); } /* Try to get FIRST and LAST figured out. */ if (spec[i] == '-') first = 0; else if (spec[i] == '^') first = 1; else if (digit_p (spec[i]) && expecting_word_spec) { for (first = 0; digit_p (spec[i]); i++) first = (first * 10) + digit_value (spec[i]); } else return ((char *)NULL); /* no valid `first' for word specifier */ if (spec[i] == '^' || spec[i] == '*') { last = (spec[i] == '^') ? 1 : '$'; /* x* abbreviates x-$ */ i++; } else if (spec[i] != '-') last = first; else { i++; if (digit_p (spec[i])) { for (last = 0; digit_p (spec[i]); i++) last = (last * 10) + digit_value (spec[i]); } else if (spec[i] == '$') { i++; last = '$'; } else if (!spec[i] || spec[i] == ':') /* could be modifier separator */ last = -1; /* x- abbreviates x-$ omitting word `$' */ } *caller_index = i; if (last >= first || last == '$' || last < 0) result = history_arg_extract (first, last, from); return (result ? result : (char *)&error_pointer); } /* Extract the args specified, starting at FIRST, and ending at LAST. The args are taken from STRING. If either FIRST or LAST is < 0, then make that arg count from the right (subtract from the number of tokens, so that FIRST = -1 means the next to last token on the line). If LAST is `$' the last arg from STRING is used. */ char * history_arg_extract (first, last, string) int first, last; char *string; { register int i, len; char *result = (char *)NULL; int size = 0, offset = 0; char **list; /* XXX - think about making history_tokenize return a struct array, each struct in array being a string and a length to avoid the calls to strlen below. */ if ((list = history_tokenize (string)) == NULL) return ((char *)NULL); for (len = 0; list[len]; len++) ; if (last < 0) last = len + last - 1; if (first < 0) first = len + first - 1; if (last == '$') last = len - 1; if (first == '$') first = len - 1; last++; if (first > len || last > len || first < 0 || last < 0) result = ((char *)NULL); else { for (size = 0, i = first; i < last; i++) size += strlen (list[i]) + 1; result = xmalloc (size + 1); for (i = first; i < last; i++) { strcpy (result + offset, list[i]); offset += strlen (list[i]); if (i + 1 < last) { result[offset++] = ' '; result[offset] = 0; } } } for (i = 0; i < len; i++) free (list[i]); free (list); return (result); } #define slashify_in_quotes "\\`\"$" /* Return an array of tokens, much as the shell might. The tokens are parsed out of STRING. */ char ** history_tokenize (string) char *string; { char **result = (char **)NULL; register int i, start, result_index, size; int len; i = result_index = size = 0; /* Get a token, and stuff it into RESULT. The tokens are split exactly where the shell would split them. */ while (string[i]) { int delimiter = 0; /* Skip leading whitespace. */ for (; string[i] && whitespace (string[i]); i++) ; if (!string[i] || string[i] == history_comment_char) return (result); start = i; if (member (string[i], "()\n")) { i++; goto got_token; } if (member (string[i], "<>;&|$")) { int peek = string[i + 1]; if (peek == string[i] && peek != '$') { if (peek == '<' && string[i + 2] == '-') i++; i += 2; goto got_token; } else { if ((peek == '&' && (string[i] == '>' || string[i] == '<')) || ((peek == '>') && (string[i] == '&')) || ((peek == '(') && (string[i] == '$'))) { i += 2; goto got_token; } } if (string[i] != '$') { i++; goto got_token; } } /* Get word from string + i; */ if (member (string[i], "\"'`")) delimiter = string[i++]; for (; string[i]; i++) { if (string[i] == '\\' && string[i + 1] == '\n') { i++; continue; } if (string[i] == '\\' && delimiter != '\'' && (delimiter != '"' || member (string[i], slashify_in_quotes))) { i++; continue; } if (delimiter && string[i] == delimiter) { delimiter = 0; continue; } if (!delimiter && (member (string[i], " \t\n;&()|<>"))) break; if (!delimiter && member (string[i], "\"'`")) delimiter = string[i]; } got_token: len = i - start; if (result_index + 2 >= size) result = (char **)xrealloc (result, ((size += 10) * sizeof (char *))); result[result_index] = xmalloc (1 + len); strncpy (result[result_index], string + start, len); result[result_index][len] = '\0'; result[++result_index] = (char *)NULL; } return (result); } #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)xmalloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "history: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Test Code */ /* */ /* **************************************************************** */ #ifdef TEST main () { char line[1024], *t; int done = 0; line[0] = 0; while (!done) { fprintf (stdout, "history%% "); t = gets (line); if (!t) strcpy (line, "quit"); if (line[0]) { char *expansion; int result; using_history (); result = history_expand (line, &expansion); strcpy (line, expansion); free (expansion); if (result) fprintf (stderr, "%s\n", line); if (result < 0) continue; add_history (line); } if (strcmp (line, "quit") == 0) done = 1; if (strcmp (line, "save") == 0) write_history (0); if (strcmp (line, "read") == 0) read_history (0); if (strcmp (line, "list") == 0) { register HIST_ENTRY **the_list = history_list (); register int i; if (the_list) for (i = 0; the_list[i]; i++) fprintf (stdout, "%d: %s\n", i + history_base, the_list[i]->line); } if (strncmp (line, "delete", strlen ("delete")) == 0) { int which; if ((sscanf (line + strlen ("delete"), "%d", &which)) == 1) { HIST_ENTRY *entry = remove_history (which); if (!entry) fprintf (stderr, "No such entry %d\n", which); else { free (entry->line); free (entry); } } else { fprintf (stderr, "non-numeric arg given to `delete'\n"); } } } } #endif /* TEST */ /* * Local variables: * compile-command: "gcc -g -DTEST -o history history.c" * end: */ lafe/readline/history.h100644 325 24 15074 6106101042 13371 0ustar dlduser/* History.h -- the names of functions that you can call in history. */ /* The structure used to store a history entry. */ typedef struct _hist_entry { char *line; char *data; } HIST_ENTRY; /* A structure used to pass the current state of the history stuff around. */ typedef struct _hist_state { HIST_ENTRY **entries; /* Pointer to the entries themselves. */ int offset; /* The location pointer within this array. */ int length; /* Number of elements within this array. */ int size; /* Number of slots allocated to this array. */ int flags; } HISTORY_STATE; /* Flag values for the `flags' member of HISTORY_STATE. */ #define HS_STIFLED 0x01 /* Initialization and state management. */ /* Begin a session in which the history functions might be used. This just initializes the interactive variables. */ extern void using_history (); /* Return the current HISTORY_STATE of the history. */ extern HISTORY_STATE *history_get_history_state (); /* Set the state of the current history array to STATE. */ extern void history_set_history_state (); /* Manage the history list. */ /* Place STRING at the end of the history list. The associated data field (if any) is set to NULL. */ extern void add_history (); /* A reasonably useless function, only here for completeness. WHICH is the magic number that tells us which element to delete. The elements are numbered from 0. */ extern HIST_ENTRY *remove_history (); /* Make the history entry at WHICH have LINE and DATA. This returns the old entry so you can dispose of the data. In the case of an invalid WHICH, a NULL pointer is returned. */ extern HIST_ENTRY *replace_history_entry (); /* Stifle the history list, remembering only MAX number of entries. */ extern void stifle_history (); /* Stop stifling the history. This returns the previous amount the history was stifled by. The value is positive if the history was stifled, negative if it wasn't. */ extern int unstifle_history (); /* Return 1 if the history is stifled, 0 if it is not. */ extern int history_is_stifled (); /* Information about the history list. */ /* Return a NULL terminated array of HIST_ENTRY which is the current input history. Element 0 of this list is the beginning of time. If there is no history, return NULL. */ extern HIST_ENTRY **history_list (); /* Returns the number which says what history element we are now looking at. */ extern int where_history (); /* Return the history entry at the current position, as determined by history_offset. If there is no entry there, return a NULL pointer. */ HIST_ENTRY *current_history (); /* Return the history entry which is logically at OFFSET in the history array. OFFSET is relative to history_base. */ extern HIST_ENTRY *history_get (); /* Return the number of bytes that the primary history entries are using. This just adds up the lengths of the_history->lines. */ extern int history_total_bytes (); /* Moving around the history list. */ /* Set the position in the history list to POS. */ int history_set_pos (); /* Back up history_offset to the previous history entry, and return a pointer to that entry. If there is no previous entry, return a NULL pointer. */ extern HIST_ENTRY *previous_history (); /* Move history_offset forward to the next item in the input_history, and return the a pointer to that entry. If there is no next entry, return a NULL pointer. */ extern HIST_ENTRY *next_history (); /* Searching the history list. */ /* Search the history for STRING, starting at history_offset. If DIRECTION < 0, then the search is through previous entries, else through subsequent. If the string is found, then current_history () is the history entry, and the value of this function is the offset in the line of that history entry that the string was found in. Otherwise, nothing is changed, and a -1 is returned. */ extern int history_search (); extern int history_search_prefix (); /* Search the history for @var{string}, starting at history_offset. The search is anchored: matching lines must begin with string. */ /* Search for STRING in the history list, starting at POS, an absolute index into the list. DIR, if negative, says to search backwards from POS, else forwards. Returns the absolute index of the history element where STRING was found, or -1 otherwise. */ extern int history_search_pos (); /* Managing the history file. */ /* Add the contents of FILENAME to the history list, a line at a time. If FILENAME is NULL, then read from ~/.history. Returns 0 if successful, or errno if not. */ extern int read_history (); /* Read a range of lines from FILENAME, adding them to the history list. Start reading at the FROM'th line and end at the TO'th. If FROM is zero, start at the beginning. If TO is less than FROM, read until the end of the file. If FILENAME is NULL, then read from ~/.history. Returns 0 if successful, or errno if not. */ extern int read_history_range (); /* Write the current history to FILENAME. If FILENAME is NULL, then write the history list to ~/.history. Values returned are as in read_history (). */ extern int write_history (); /* Append NELEMENT entries to FILENAME. The entries appended are from the end of the list minus NELEMENTs up to the end of the list. */ int append_history (); /* Truncate the history file, leaving only the last NLINES lines. */ extern int history_truncate_file (); /* History expansion. */ /* Expand the string STRING, placing the result into OUTPUT, a pointer to a string. Returns: 0) If no expansions took place (or, if the only change in the text was the de-slashifying of the history expansion character) 1) If expansions did take place -1) If there was an error in expansion. 2) If the returned line should just be printed. If an error ocurred in expansion, then OUTPUT contains a descriptive error message. */ extern int history_expand (); /* Extract a string segment consisting of the FIRST through LAST arguments present in STRING. Arguments are broken up as in the shell. */ extern char *history_arg_extract (); /* Return the text of the history event beginning at the current offset into STRING. */ extern char *get_history_event (); /* Return an array of tokens, much as the shell might. The tokens are parsed out of STRING. */ extern char **history_tokenize (); /* Exported history variables. */ extern int history_base; extern int history_length; extern int max_input_history; extern char history_expansion_char; extern char history_subst_char; extern char history_comment_char; extern char *history_no_expand_chars; lafe/readline/terminfo.dat100644 325 24 752355 6106101043 14067 0ustar dlduser tttteeeerrrrmmmmiiiinnnnffffoooo((((4444)))) tttteeeerrrrmmmmiiiinnnnffffoooo((((4444)))) NNNNAAAAMMMMEEEE _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo - terminal capability data base SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo_////_????_////_**** DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo is a database produced by _tttt_iiii_cccc that describes the capabilities of devices such as terminals and printers. Devices are described in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source files by specifying a set of capabilities, by quantifying certain aspects of the device, and by specifying character sequences that effect particular results. This database is often used by screen oriented applications such as _vvvv_iiii and _cccc_uuuu_rrrr_ssss_eeee_ssss programs, as well as by some UNIX system commands such as _llll_ssss and _mmmm_oooo_rrrr_eeee. This usage allows them to work with a variety of devices without changes to the programs. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source files consist of one or more device descriptions. Each description consists of a header (beginning in column 1) and one or more lines that list the features for that particular device. Every line in a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file must end in a comma (_,,,,). Every line in a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file except the header must be indented with one or more white spaces (either spaces or tabs). Entries in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source files consist of a number of comma-separated fields. White space after each comma is ignored. Embedded commas must be escaped by using a backslash. The following example shows the format of a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file. alias | alias | ... | alias | _l_o_n_g_n_a_m_e, <_w_h_i_t1_e _s_p_a_c_e> 2_aaaa_mmmm_,,,, _llll_iiii_nnnn_eeee_ssss _####_2222_4444_,,,, n <_w_h_i_t_e _s_p_a_c_e> _hhhh_oooo_mmmm_eeee_====_\\\\_EEEE_eeee_hhhh_,,,, The first line, commonly referred to as the header line, must begin in column one and must contain at least two aliases separated by vertical bars. The last field in the header line must be the long name of the device and it may contain any string. Alias names must be unique in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo database and they must conform to UNIX system file naming conventions [see _tttt_iiii_cccc(1M)]; they cannot, for example, contain white space or slashes. Every device must be assigned a name, such as "vt100". Device names (except the long name) should be chosen using the following conventions. The name should not contain hyphens because hyphens are reserved for use when adding suffixes that indicate special modes. These special modes may be modes that the hardware can be in, or user preferences. To assign a special mode to a particular device, append a suffix consisting of a hyphen and an indicator of the mode to the device name. For example, the _----_wwww suffix means "wide mode"; when specified, it allows for a width of 132 columns instead of the standard 80 columns. Therefore, if you want to use a vt100 device set to wide mode, name the device "vt100-w." Use the following suffixes where possible. Suffix Meaning Example _----_wwww Wide mode (more than 80 columns) _5555_4444_1111_0000_----_wwww PPPPaaaaggggeeee 1111 tttteeeerrrrmmmmiiiinnnnffffoooo((((4444)))) tttteeeerrrrmmmmiiiinnnnffffoooo((((4444)))) _----_aaaa_mmmm With auto. margins (usually default) _vvvv_tttt_1111_0000_0000_----_aaaa_mmmm _----_nnnn_aaaa_mmmm Without automatic margins _vvvv_tttt_1111_0000_0000_----_nnnn_aaaa_mmmm -_n Number of lines on the screen _2222_3333_0000_0000_----_4444_0000 _----_nnnn_aaaa No arrow keys (leave them in local) _cccc_1111_0000_0000_----_nnnn_aaaa -_np Number of pages of memory _cccc_1111_0000_0000_----_4444_pppp _----_rrrr_vvvv Reverse video _4444_4444_1111_5555_----_rrrr_vvvv The _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo reference manual page is organized in two sections: "DEVICE CAPABILITIES" and "PRINTER CAPABILITIES." PPPPAAAARRRRTTTT 1111:::: DDDDEEEEVVVVIIIICCCCEEEE CCCCAAAAPPPPAAAABBBBIIIILLLLIIIITTTTIIIIEEEESSSS Capabilities in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo are of three types: Boolean capabilities (which show that a device has or does not have a particular feature), numeric capabilities (which quantify particular features of a device), and string capabilities (which provide sequences that can be used to perform particular operations on devices). In the following table, a VVVVaaaarrrriiiiaaaabbbblllleeee is the name by which a CCCC programmer accesses a capability (at the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo level). A CCCCaaaappppnnnnaaaammmmeeee is the short name for a capability specified in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file. It is used by a person updating the source file and by the _tttt_pppp_uuuu_tttt command. A TTTTeeeerrrrmmmmccccaaaapppp CCCCooooddddeeee is a two-letter sequence that corresponds to the _tttt_eeee_rrrr_mmmm_cccc_aaaa_pppp capability name. (Note that _tttt_eeee_rrrr_mmmm_cccc_aaaa_pppp is no longer supported.) Capability names have no real length limit, but an informal limit of five characters has been adopted to keep them short. Whenever possible, capability names are chosen to be the same as or similar to those specified by the ANSI X3.64-1979 standard. Semantics are also intended to match those of the ANSI standard. All string capabilities listed below may have padding specified, with the exception of those used for input. Input capabilities, listed under the SSSSttttrrrriiiinnnnggggssss section in the following tables, have names beginning with _kkkk_eeee_yyyy_____. The _####_iiii symbol in the description field of the following tables refers to the _ith parameter. BBBBoooooooolllleeeeaaaannnnssss Cap- Termcap Variable name Code Description PPPPaaaaggggeeee 2222 _aaaa_uuuu_tttt_oooo______llll_eeee_ffff_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn _bbbb_wwww _bbbb_wwww _cccc_uuuu_bbbb_1111 wraps from column 0 to last column _aaaa_uuuu_tttt_oooo______rrrr_iiii_gggg_hhhh_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn _aaaa_mmmm _aaaa_mmmm Terminal has automatic margins _bbbb_aaaa_cccc_kkkk______cccc_oooo_llll_oooo_rrrr______eeee_rrrr_aaaa_ssss_eeee _bbbb_cccc_eeee _bbbb_eeee Screen erased with background color _cccc_aaaa_nnnn______cccc_hhhh_aaaa_nnnn_gggg_eeee _cccc_cccc_cccc _cccc_cccc Terminal can re-define existing color _cccc_eeee_oooo_llll______ssss_tttt_aaaa_nnnn_dddd_oooo_uuuu_tttt______gggg_llll_iiii_tttt_cccc_hhhh _xxxx_hhhh_pppp _xxxx_ssss Standout not erased by overwriting (hp) _cccc_oooo_llll______aaaa_dddd_dddd_rrrr______gggg_llll_iiii_tttt_cccc_hhhh _xxxx_hhhh_pppp_aaaa _YYYY_AAAA Only positive motion for _hhhh_pppp_aaaa/_mmmm_hhhh_pppp_aaaa caps _cccc_pppp_iiii______cccc_hhhh_aaaa_nnnn_gggg_eeee_ssss______rrrr_eeee_ssss _cccc_pppp_iiii_xxxx _YYYY_FFFF Changing character pitch changes resolution _cccc_rrrr______cccc_aaaa_nnnn_cccc_eeee_llll_ssss______mmmm_iiii_cccc_rrrr_oooo______mmmm_oooo_dddd_eeee _cccc_rrrr_xxxx_mmmm _YYYY_BBBB Using _cccc_rrrr turns off micro mode _eeee_aaaa_tttt______nnnn_eeee_wwww_llll_iiii_nnnn_eeee______gggg_llll_iiii_tttt_cccc_hhhh _xxxx_eeee_nnnn_llll _xxxx_nnnn Newline ignored after 80 columns (Concept) _eeee_rrrr_aaaa_ssss_eeee______oooo_vvvv_eeee_rrrr_ssss_tttt_rrrr_iiii_kkkk_eeee _eeee_oooo _eeee_oooo Can erase overstrikes with a blank _gggg_eeee_nnnn_eeee_rrrr_iiii_cccc______tttt_yyyy_pppp_eeee _gggg_nnnn _gggg_nnnn Generic line type (_e._g., dialup, switch) _hhhh_aaaa_rrrr_dddd______cccc_oooo_pppp_yyyy _hhhh_cccc _hhhh_cccc Hardcopy terminal _hhhh_aaaa_rrrr_dddd______cccc_uuuu_rrrr_ssss_oooo_rrrr _cccc_hhhh_tttt_ssss _HHHH_CCCC Cursor is hard to see _hhhh_aaaa_ssss______mmmm_eeee_tttt_aaaa______kkkk_eeee_yyyy _kkkk_mmmm _kkkk_mmmm Has a meta key (shift, sets parity bit) _hhhh_aaaa_ssss______pppp_rrrr_iiii_nnnn_tttt______wwww_hhhh_eeee_eeee_llll _dddd_aaaa_iiii_ssss_yyyy _YYYY_CCCC Printer needs operator to change character set _hhhh_aaaa_ssss______ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee _hhhh_ssss _hhhh_ssss Has extra "status line" _hhhh_uuuu_eeee______llll_iiii_gggg_hhhh_tttt_nnnn_eeee_ssss_ssss______ssss_aaaa_tttt_uuuu_rrrr_aaaa_tttt_iiii_oooo_nnnn _hhhh_llll_ssss _hhhh_llll Terminal uses only HLS color notation (Tektronix) _iiii_nnnn_ssss_eeee_rrrr_tttt______nnnn_uuuu_llll_llll______gggg_llll_iiii_tttt_cccc_hhhh _iiii_nnnn _iiii_nnnn Insert mode distinguishes nulls _llll_pppp_iiii______cccc_hhhh_aaaa_nnnn_gggg_eeee_ssss______rrrr_eeee_ssss _llll_pppp_iiii_xxxx _YYYY_GGGG Changing line pitch changes resolution _mmmm_eeee_mmmm_oooo_rrrr_yyyy______aaaa_bbbb_oooo_vvvv_eeee _dddd_aaaa _dddd_aaaa Display may be retained above the screen _mmmm_eeee_mmmm_oooo_rrrr_yyyy______bbbb_eeee_llll_oooo_wwww _dddd_bbbb _dddd_bbbb Display may be retained below the screen _mmmm_oooo_vvvv_eeee______iiii_nnnn_ssss_eeee_rrrr_tttt______mmmm_oooo_dddd_eeee _mmmm_iiii_rrrr _mmmm_iiii Safe to move while in insert mode _mmmm_oooo_vvvv_eeee______ssss_tttt_aaaa_nnnn_dddd_oooo_uuuu_tttt______mmmm_oooo_dddd_eeee _mmmm_ssss_gggg_rrrr _mmmm_ssss Safe to move in standout modes _nnnn_eeee_eeee_dddd_ssss______xxxx_oooo_nnnn______xxxx_oooo_ffff_ffff _nnnn_xxxx_oooo_nnnn _nnnn_xxxx Padding won't work, xon/xoff required _nnnn_oooo______eeee_ssss_cccc______cccc_tttt_llll_cccc _xxxx_ssss_bbbb _xxxx_bbbb Beehive (f1=escape, f2=ctrl C) _nnnn_oooo_nnnn______rrrr_eeee_vvvv______rrrr_mmmm_cccc_uuuu_pppp _nnnn_rrrr_rrrr_mmmm_cccc _NNNN_RRRR _ssss_mmmm_cccc_uuuu_pppp does not reverse _rrrr_mmmm_cccc_uuuu_pppp _nnnn_oooo______pppp_aaaa_dddd______cccc_hhhh_aaaa_rrrr _nnnn_pppp_cccc _NNNN_PPPP Pad character doesn't exist _oooo_vvvv_eeee_rrrr______ssss_tttt_rrrr_iiii_kkkk_eeee _oooo_ssss _oooo_ssss Terminal overstrikes on hard-copy terminal _pppp_rrrr_tttt_rrrr______ssss_iiii_llll_eeee_nnnn_tttt _mmmm_cccc_5555_iiii _5555_iiii Printer won't echo on screen _rrrr_oooo_wwww______aaaa_dddd_dddd_rrrr______gggg_llll_iiii_tttt_cccc_hhhh _xxxx_vvvv_pppp_aaaa _YYYY_DDDD Only positive motion for _vvvv_pppp_aaaa/_mmmm_vvvv_pppp_aaaa caps _ssss_eeee_mmmm_iiii______aaaa_uuuu_tttt_oooo______rrrr_iiii_gggg_hhhh_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_aaaa_mmmm _YYYY_EEEE Printing in last column causes _cccc_rrrr _ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee______eeee_ssss_cccc______oooo_kkkk _eeee_ssss_llll_oooo_kkkk _eeee_ssss Escape can be used on the status line _dddd_eeee_ssss_tttt______tttt_aaaa_bbbb_ssss______mmmm_aaaa_gggg_iiii_cccc______ssss_mmmm_ssss_oooo _xxxx_tttt _xxxx_tttt Destructive tabs, magic _ssss_mmmm_ssss_oooo char (t1061) _tttt_iiii_llll_dddd_eeee______gggg_llll_iiii_tttt_cccc_hhhh _hhhh_zzzz _hhhh_zzzz Hazeltine; can't print tilde (~) _tttt_rrrr_aaaa_nnnn_ssss_pppp_aaaa_rrrr_eeee_nnnn_tttt______uuuu_nnnn_dddd_eeee_rrrr_llll_iiii_nnnn_eeee _uuuu_llll _uuuu_llll Underline character overstrikes _xxxx_oooo_nnnn______xxxx_oooo_ffff_ffff _xxxx_oooo_nnnn _xxxx_oooo Terminal uses xon/xoff handshaking NNNNuuuummmmbbbbeeeerrrrssss Cap- Termcap Variable name Code Description PPPPaaaaggggeeee 3333 _bbbb_uuuu_ffff_ffff_eeee_rrrr______cccc_aaaa_pppp_aaaa_cccc_iiii_tttt_yyyy _bbbb_uuuu_ffff_ssss_zzzz _YYYY_aaaa Number of bytes buffered before printing _cccc_oooo_llll_uuuu_mmmm_nnnn_ssss _cccc_oooo_llll_ssss _cccc_oooo Number of columns in a line _dddd_oooo_tttt______vvvv_eeee_rrrr_tttt______ssss_pppp_aaaa_cccc_iiii_nnnn_gggg _ssss_pppp_iiii_nnnn_vvvv _YYYY_bbbb Spacing of pins vertically in pins per inch _dddd_oooo_tttt______hhhh_oooo_rrrr_zzzz______ssss_pppp_aaaa_cccc_iiii_nnnn_gggg _ssss_pppp_iiii_nnnn_hhhh _YYYY_cccc Spacing of dots horizontally in dots per inch _iiii_nnnn_iiii_tttt______tttt_aaaa_bbbb_ssss _iiii_tttt _iiii_tttt Tabs initially every # spaces _llll_aaaa_bbbb_eeee_llll______hhhh_eeee_iiii_gggg_hhhh_tttt _llll_hhhh _llll_hhhh Number of rows in each label _llll_aaaa_bbbb_eeee_llll______wwww_iiii_dddd_tttt_hhhh _llll_wwww _llll_wwww Number of columns in each label _llll_iiii_nnnn_eeee_ssss _llll_iiii_nnnn_eeee_ssss _llll_iiii Number of lines on a screen or a page _llll_iiii_nnnn_eeee_ssss______oooo_ffff______mmmm_eeee_mmmm_oooo_rrrr_yyyy _llll_mmmm _llll_mmmm Lines of memory if > _llll_iiii_nnnn_eeee_ssss; _0000 means varies _mmmm_aaaa_gggg_iiii_cccc______cccc_oooo_oooo_kkkk_iiii_eeee______gggg_llll_iiii_tttt_cccc_hhhh _xxxx_mmmm_cccc _ssss_gggg Number of blank characters left by _ssss_mmmm_ssss_oooo or _rrrr_mmmm_ssss_oooo _mmmm_aaaa_xxxx______cccc_oooo_llll_oooo_rrrr_ssss _cccc_oooo_llll_oooo_rrrr_ssss _CCCC_oooo Maximum number of colors on the screen _mmmm_aaaa_xxxx______mmmm_iiii_cccc_rrrr_oooo______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _mmmm_aaaa_dddd_dddd_rrrr _YYYY_dddd Maximum value in _mmmm_iiii_cccc_rrrr_oooo______...._...._....______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _mmmm_aaaa_xxxx______mmmm_iiii_cccc_rrrr_oooo______jjjj_uuuu_mmmm_pppp _mmmm_jjjj_uuuu_mmmm_pppp _YYYY_eeee Maximum value in _pppp_aaaa_rrrr_mmmm______...._...._....______mmmm_iiii_cccc_rrrr_oooo _mmmm_aaaa_xxxx______pppp_aaaa_iiii_rrrr_ssss _pppp_aaaa_iiii_rrrr_ssss _pppp_aaaa Maximum number of color-pairs on the screen _mmmm_iiii_cccc_rrrr_oooo______cccc_oooo_llll______ssss_iiii_zzzz_eeee _mmmm_cccc_ssss _YYYY_ffff Character step size when in micro mode _mmmm_iiii_cccc_rrrr_oooo______llll_iiii_nnnn_eeee______ssss_iiii_zzzz_eeee _mmmm_llll_ssss _YYYY_gggg Line step size when in micro mode _nnnn_oooo______cccc_oooo_llll_oooo_rrrr______vvvv_iiii_dddd_eeee_oooo _nnnn_cccc_vvvv _NNNN_CCCC Video attributes that can't be used with colors _nnnn_uuuu_mmmm_bbbb_eeee_rrrr______oooo_ffff______pppp_iiii_nnnn_ssss _nnnn_pppp_iiii_nnnn_ssss _YYYY_hhhh Number of pins in print-head _nnnn_uuuu_mmmm______llll_aaaa_bbbb_eeee_llll_ssss _nnnn_llll_aaaa_bbbb _NNNN_llll Number of labels on screen (start at 1) _oooo_uuuu_tttt_pppp_uuuu_tttt______rrrr_eeee_ssss______cccc_hhhh_aaaa_rrrr _oooo_rrrr_cccc _YYYY_iiii Horizontal resolution in units per character _oooo_uuuu_tttt_pppp_uuuu_tttt______rrrr_eeee_ssss______llll_iiii_nnnn_eeee _oooo_rrrr_llll _YYYY_jjjj Vertical resolution in units per line _oooo_uuuu_tttt_pppp_uuuu_tttt______rrrr_eeee_ssss______hhhh_oooo_rrrr_zzzz______iiii_nnnn_cccc_hhhh _oooo_rrrr_hhhh_iiii _YYYY_kkkk Horizontal resolution in units per inch _oooo_uuuu_tttt_pppp_uuuu_tttt______rrrr_eeee_ssss______vvvv_eeee_rrrr_tttt______iiii_nnnn_cccc_hhhh _oooo_rrrr_vvvv_iiii _YYYY_llll Vertical resolution in units per inch _pppp_aaaa_dddd_dddd_iiii_nnnn_gggg______bbbb_aaaa_uuuu_dddd______rrrr_aaaa_tttt_eeee _pppp_bbbb _pppp_bbbb Lowest baud rate where padding needed _vvvv_iiii_rrrr_tttt_uuuu_aaaa_llll______tttt_eeee_rrrr_mmmm_iiii_nnnn_aaaa_llll _vvvv_tttt _vvvv_tttt Virtual terminal number (UNIX system) _wwww_iiii_dddd_eeee______cccc_hhhh_aaaa_rrrr______ssss_iiii_zzzz_eeee _wwww_iiii_dddd_cccc_ssss _YYYY_nnnn Character step size when in double wide mode _wwww_iiii_dddd_tttt_hhhh______ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee _wwww_ssss_llll _wwww_ssss Number of columns in status line SSSSttttrrrriiiinnnnggggssss Cap- Termcap Variable name Code Description PPPPaaaaggggeeee 4444 _aaaa_cccc_ssss______cccc_hhhh_aaaa_rrrr_ssss _aaaa_cccc_ssss_cccc _aaaa_cccc Graphic charset pairs aAbBcC _aaaa_llll_tttt______ssss_cccc_aaaa_nnnn_cccc_oooo_dddd_eeee______eeee_ssss_cccc _ssss_cccc_eeee_ssss_cccc_aaaa _SSSS_8888 Alternate escape for scancode emulation (default is for vt100) _bbbb_aaaa_cccc_kkkk______tttt_aaaa_bbbb _cccc_bbbb_tttt _bbbb_tttt Back tab _bbbb_eeee_llll_llll _bbbb_eeee_llll _bbbb_llll Audible signal (bell) _bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee______rrrr_eeee_pppp_eeee_aaaa_tttt _bbbb_iiii_rrrr_eeee_pppp _ZZZZ_yyyy Repeat bit-image cell #1 #2 times (use tparm) _bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee______nnnn_eeee_wwww_llll_iiii_nnnn_eeee _bbbb_iiii_nnnn_eeee_llll _ZZZZ_zzzz Move to next row of the bit image (use tparm) _bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee______cccc_aaaa_rrrr_rrrr_iiii_aaaa_gggg_eeee______rrrr_eeee_tttt_uuuu_rrrr_nnnn _bbbb_iiii_cccc_rrrr _YYYY_vvvv Move to beginning of same row (use tparm) _cccc_aaaa_rrrr_rrrr_iiii_aaaa_gggg_eeee______rrrr_eeee_tttt_uuuu_rrrr_nnnn _cccc_rrrr _cccc_rrrr Carriage return _cccc_hhhh_aaaa_nnnn_gggg_eeee______cccc_hhhh_aaaa_rrrr______pppp_iiii_tttt_cccc_hhhh _cccc_pppp_iiii _ZZZZ_AAAA Change number of characters per inch _cccc_hhhh_aaaa_nnnn_gggg_eeee______llll_iiii_nnnn_eeee______pppp_iiii_tttt_cccc_hhhh _llll_pppp_iiii _ZZZZ_BBBB Change number of lines per inch _cccc_hhhh_aaaa_nnnn_gggg_eeee______rrrr_eeee_ssss______hhhh_oooo_rrrr_zzzz _cccc_hhhh_rrrr _ZZZZ_CCCC Change horizontal resolution _cccc_hhhh_aaaa_nnnn_gggg_eeee______rrrr_eeee_ssss______vvvv_eeee_rrrr_tttt _cccc_vvvv_rrrr _ZZZZ_DDDD Change vertical resolution _cccc_hhhh_aaaa_nnnn_gggg_eeee______ssss_cccc_rrrr_oooo_llll_llll______rrrr_eeee_gggg_iiii_oooo_nnnn _cccc_ssss_rrrr _cccc_ssss Change to lines #1 through #2 (vt100) _cccc_hhhh_aaaa_rrrr______pppp_aaaa_dddd_dddd_iiii_nnnn_gggg _rrrr_mmmm_pppp _rrrr_PPPP Like _iiii_pppp but when in replace mode _cccc_hhhh_aaaa_rrrr______ssss_eeee_tttt______nnnn_aaaa_mmmm_eeee_ssss _cccc_ssss_nnnn_mmmm _ZZZZ_yyyy List of character set names _cccc_llll_eeee_aaaa_rrrr______aaaa_llll_llll______tttt_aaaa_bbbb_ssss _tttt_bbbb_cccc _cccc_tttt Clear all tab stops _cccc_llll_eeee_aaaa_rrrr______mmmm_aaaa_rrrr_gggg_iiii_nnnn_ssss _mmmm_gggg_cccc _MMMM_CCCC Clear all margins (top, bottom, and sides) _cccc_llll_eeee_aaaa_rrrr______ssss_cccc_rrrr_eeee_eeee_nnnn _cccc_llll_eeee_aaaa_rrrr _cccc_llll Clear screen and home cursor _cccc_llll_rrrr______bbbb_oooo_llll _eeee_llll_1111 _cccc_bbbb Clear to beginning of line, inclusive _cccc_llll_rrrr______eeee_oooo_llll _eeee_llll _cccc_eeee Clear to end of line _cccc_llll_rrrr______eeee_oooo_ssss _eeee_dddd _cccc_dddd Clear to end of display _cccc_oooo_dddd_eeee______ssss_eeee_tttt______iiii_nnnn_iiii_tttt _cccc_ssss_iiii_nnnn _cccc_iiii Init sequence for multiple codesets _cccc_oooo_llll_oooo_rrrr______nnnn_aaaa_mmmm_eeee_ssss _cccc_oooo_llll_oooo_rrrr_nnnn_mmmm _YYYY_wwww Give name for color #1 _cccc_oooo_llll_uuuu_mmmm_nnnn______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _hhhh_pppp_aaaa _cccc_hhhh Horizontal position absolute _cccc_oooo_mmmm_mmmm_aaaa_nnnn_dddd______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr _cccc_mmmm_dddd_cccc_hhhh _CCCC_CCCC Terminal settable cmd character in prototype _cccc_uuuu_rrrr_ssss_oooo_rrrr______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _cccc_uuuu_pppp _cccc_mmmm Move to row #1 col #2 _cccc_uuuu_rrrr_ssss_oooo_rrrr______dddd_oooo_wwww_nnnn _cccc_uuuu_dddd_1111 _dddd_oooo Down one line _cccc_uuuu_rrrr_ssss_oooo_rrrr______hhhh_oooo_mmmm_eeee _hhhh_oooo_mmmm_eeee _hhhh_oooo Home cursor (if no _cccc_uuuu_pppp) _cccc_uuuu_rrrr_ssss_oooo_rrrr______iiii_nnnn_vvvv_iiii_ssss_iiii_bbbb_llll_eeee _cccc_iiii_vvvv_iiii_ssss _vvvv_iiii Make cursor invisible _cccc_uuuu_rrrr_ssss_oooo_rrrr______llll_eeee_ffff_tttt _cccc_uuuu_bbbb_1111 _llll_eeee Move left one space. _cccc_uuuu_rrrr_ssss_oooo_rrrr______mmmm_eeee_mmmm______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _mmmm_rrrr_cccc_uuuu_pppp _CCCC_MMMM Memory relative cursor addressing _cccc_uuuu_rrrr_ssss_oooo_rrrr______nnnn_oooo_rrrr_mmmm_aaaa_llll _cccc_nnnn_oooo_rrrr_mmmm _vvvv_eeee Make cursor appear normal (undo _vvvv_ssss_////_vvvv_iiii) _cccc_uuuu_rrrr_ssss_oooo_rrrr______rrrr_iiii_gggg_hhhh_tttt _cccc_uuuu_ffff_1111 _nnnn_dddd Non-destructive space (cursor or carriage right) _cccc_uuuu_rrrr_ssss_oooo_rrrr______tttt_oooo______llll_llll _llll_llll _llll_llll Last line, first column (if no _cccc_uuuu_pppp) _cccc_uuuu_rrrr_ssss_oooo_rrrr______uuuu_pppp _cccc_uuuu_uuuu_1111 _uuuu_pppp Upline (cursor up) _cccc_uuuu_rrrr_ssss_oooo_rrrr______vvvv_iiii_ssss_iiii_bbbb_llll_eeee _cccc_vvvv_vvvv_iiii_ssss _vvvv_ssss Make cursor very visible _dddd_eeee_ffff_iiii_nnnn_eeee______bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee______rrrr_eeee_gggg_iiii_oooo_nnnn _dddd_eeee_ffff_bbbb_iiii _YYYY_xxxx Define rectangular bit-image region (use tparm) _dddd_eeee_ffff_iiii_nnnn_eeee______cccc_hhhh_aaaa_rrrr _dddd_eeee_ffff_cccc _ZZZZ_EEEE Define a character in a character set|- _dddd_eeee_llll_eeee_tttt_eeee______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr _dddd_cccc_hhhh_1111 _dddd_cccc Delete character _dddd_eeee_llll_eeee_tttt_eeee______llll_iiii_nnnn_eeee _dddd_llll_1111 _dddd_llll Delete line _dddd_eeee_vvvv_iiii_cccc_eeee______tttt_yyyy_pppp_eeee _dddd_eeee_vvvv_tttt _dddd_vvvv Indicate language/codeset support _dddd_iiii_ssss______ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee _dddd_ssss_llll _dddd_ssss Disable status line _dddd_iiii_ssss_pppp_llll_aaaa_yyyy______pppp_cccc______cccc_hhhh_aaaa_rrrr _dddd_iiii_ssss_pppp_cccc _SSSS_1111 Display PC character _dddd_oooo_wwww_nnnn______hhhh_aaaa_llll_ffff______llll_iiii_nnnn_eeee _hhhh_dddd _hhhh_dddd Half-line down (forward 1/2 linefeed) PPPPaaaaggggeeee 5555 _eeee_nnnn_aaaa______aaaa_cccc_ssss _eeee_nnnn_aaaa_cccc_ssss _eeee_AAAA Enable alternate character set _eeee_nnnn_dddd______bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee______rrrr_eeee_gggg_iiii_oooo_nnnn _eeee_nnnn_dddd_bbbb_iiii _YYYY_yyyy End a bit-image region (use tparm) _eeee_nnnn_tttt_eeee_rrrr______aaaa_llll_tttt______cccc_hhhh_aaaa_rrrr_ssss_eeee_tttt______mmmm_oooo_dddd_eeee _ssss_mmmm_aaaa_cccc_ssss _aaaa_ssss Start alternate character set _eeee_nnnn_tttt_eeee_rrrr______aaaa_mmmm______mmmm_oooo_dddd_eeee _ssss_mmmm_aaaa_mmmm _SSSS_AAAA Turn on automatic margins _eeee_nnnn_tttt_eeee_rrrr______bbbb_llll_iiii_nnnn_kkkk______mmmm_oooo_dddd_eeee _bbbb_llll_iiii_nnnn_kkkk _mmmm_bbbb Turn on blinking _eeee_nnnn_tttt_eeee_rrrr______bbbb_oooo_llll_dddd______mmmm_oooo_dddd_eeee _bbbb_oooo_llll_dddd _mmmm_dddd Turn on bold (extra bright) mode _eeee_nnnn_tttt_eeee_rrrr______cccc_aaaa______mmmm_oooo_dddd_eeee _ssss_mmmm_cccc_uuuu_pppp _tttt_iiii String to begin programs that use _cccc_uuuu_pppp _eeee_nnnn_tttt_eeee_rrrr______dddd_eeee_llll_eeee_tttt_eeee______mmmm_oooo_dddd_eeee _ssss_mmmm_dddd_cccc _dddd_mmmm Delete mode (enter) _eeee_nnnn_tttt_eeee_rrrr______dddd_iiii_mmmm______mmmm_oooo_dddd_eeee _dddd_iiii_mmmm _mmmm_hhhh Turn on half-bright mode _eeee_nnnn_tttt_eeee_rrrr______dddd_oooo_uuuu_bbbb_llll_eeee_wwww_iiii_dddd_eeee______mmmm_oooo_dddd_eeee _ssss_wwww_iiii_dddd_mmmm _ZZZZ_FFFF Enable double wide printing _eeee_nnnn_tttt_eeee_rrrr______dddd_rrrr_aaaa_ffff_tttt______qqqq_uuuu_aaaa_llll_iiii_tttt_yyyy _ssss_dddd_rrrr_ffff_qqqq _ZZZZ_GGGG Set draft quality print _eeee_nnnn_tttt_eeee_rrrr______iiii_nnnn_ssss_eeee_rrrr_tttt______mmmm_oooo_dddd_eeee _ssss_mmmm_iiii_rrrr _iiii_mmmm Insert mode (enter) _eeee_nnnn_tttt_eeee_rrrr______iiii_tttt_aaaa_llll_iiii_cccc_ssss______mmmm_oooo_dddd_eeee _ssss_iiii_tttt_mmmm _ZZZZ_HHHH Enable italics _eeee_nnnn_tttt_eeee_rrrr______llll_eeee_ffff_tttt_wwww_aaaa_rrrr_dddd______mmmm_oooo_dddd_eeee _ssss_llll_mmmm _ZZZZ_IIII Enable leftward carriage motion _eeee_nnnn_tttt_eeee_rrrr______mmmm_iiii_cccc_rrrr_oooo______mmmm_oooo_dddd_eeee _ssss_mmmm_iiii_cccc_mmmm _ZZZZ_JJJJ Enable micro motion capabilities _eeee_nnnn_tttt_eeee_rrrr______nnnn_eeee_aaaa_rrrr______llll_eeee_tttt_tttt_eeee_rrrr______qqqq_uuuu_aaaa_llll_iiii_tttt_yyyy _ssss_nnnn_llll_qqqq _ZZZZ_KKKK Set near-letter quality print _eeee_nnnn_tttt_eeee_rrrr______nnnn_oooo_rrrr_mmmm_aaaa_llll______qqqq_uuuu_aaaa_llll_iiii_tttt_yyyy _ssss_nnnn_rrrr_mmmm_qqqq _ZZZZ_LLLL Set normal quality print _eeee_nnnn_tttt_eeee_rrrr______pppp_cccc______cccc_hhhh_aaaa_rrrr_ssss_eeee_tttt______mmmm_oooo_dddd_eeee _ssss_mmmm_pppp_cccc_hhhh _SSSS_2222 Enter PC character display mode _eeee_nnnn_tttt_eeee_rrrr______pppp_rrrr_oooo_tttt_eeee_cccc_tttt_eeee_dddd______mmmm_oooo_dddd_eeee _pppp_rrrr_oooo_tttt _mmmm_pppp Turn on protected mode _eeee_nnnn_tttt_eeee_rrrr______rrrr_eeee_vvvv_eeee_rrrr_ssss_eeee______mmmm_oooo_dddd_eeee _rrrr_eeee_vvvv _mmmm_rrrr Turn on reverse video mode _eeee_nnnn_tttt_eeee_rrrr______ssss_cccc_aaaa_nnnn_cccc_oooo_dddd_eeee______mmmm_oooo_dddd_eeee _ssss_mmmm_ssss_cccc _SSSS_4444 Enter PC scancode mode _eeee_nnnn_tttt_eeee_rrrr______ssss_eeee_cccc_uuuu_rrrr_eeee______mmmm_oooo_dddd_eeee _iiii_nnnn_vvvv_iiii_ssss _mmmm_kkkk Turn on blank mode (characters invisible) _eeee_nnnn_tttt_eeee_rrrr______ssss_hhhh_aaaa_dddd_oooo_wwww______mmmm_oooo_dddd_eeee _ssss_ssss_hhhh_mmmm _ZZZZ_MMMM Enable shadow printing _eeee_nnnn_tttt_eeee_rrrr______ssss_tttt_aaaa_nnnn_dddd_oooo_uuuu_tttt______mmmm_oooo_dddd_eeee _ssss_mmmm_ssss_oooo _ssss_oooo Begin standout mode _eeee_nnnn_tttt_eeee_rrrr______ssss_uuuu_bbbb_ssss_cccc_rrrr_iiii_pppp_tttt______mmmm_oooo_dddd_eeee _ssss_ssss_uuuu_bbbb_mmmm _ZZZZ_NNNN Enable subscript printing _eeee_nnnn_tttt_eeee_rrrr______ssss_uuuu_pppp_eeee_rrrr_ssss_cccc_rrrr_iiii_pppp_tttt______mmmm_oooo_dddd_eeee _ssss_ssss_uuuu_pppp_mmmm _ZZZZ_OOOO Enable superscript printing _eeee_nnnn_tttt_eeee_rrrr______uuuu_nnnn_dddd_eeee_rrrr_llll_iiii_nnnn_eeee______mmmm_oooo_dddd_eeee _ssss_mmmm_uuuu_llll _uuuu_ssss Start underscore mode _eeee_nnnn_tttt_eeee_rrrr______uuuu_pppp_wwww_aaaa_rrrr_dddd______mmmm_oooo_dddd_eeee _ssss_uuuu_mmmm _ZZZZ_PPPP Enable upward carriage motion _eeee_nnnn_tttt_eeee_rrrr______xxxx_oooo_nnnn______mmmm_oooo_dddd_eeee _ssss_mmmm_xxxx_oooo_nnnn _SSSS_XXXX Turn on xon/xoff handshaking _eeee_rrrr_aaaa_ssss_eeee______cccc_hhhh_aaaa_rrrr_ssss _eeee_cccc_hhhh _eeee_cccc Erase #1 characters _eeee_xxxx_iiii_tttt______aaaa_llll_tttt______cccc_hhhh_aaaa_rrrr_ssss_eeee_tttt______mmmm_oooo_dddd_eeee _rrrr_mmmm_aaaa_cccc_ssss _aaaa_eeee End alternate character set _eeee_xxxx_iiii_tttt______aaaa_mmmm______mmmm_oooo_dddd_eeee _rrrr_mmmm_aaaa_mmmm _RRRR_AAAA Turn off automatic margins _eeee_xxxx_iiii_tttt______aaaa_tttt_tttt_rrrr_iiii_bbbb_uuuu_tttt_eeee______mmmm_oooo_dddd_eeee _ssss_gggg_rrrr_0000 _mmmm_eeee Turn off all attributes _eeee_xxxx_iiii_tttt______cccc_aaaa______mmmm_oooo_dddd_eeee _rrrr_mmmm_cccc_uuuu_pppp _tttt_eeee String to end programs that use _cccc_uuuu_pppp _eeee_xxxx_iiii_tttt______dddd_eeee_llll_eeee_tttt_eeee______mmmm_oooo_dddd_eeee _rrrr_mmmm_dddd_cccc _eeee_dddd End delete mode _eeee_xxxx_iiii_tttt______dddd_oooo_uuuu_bbbb_llll_eeee_wwww_iiii_dddd_eeee______mmmm_oooo_dddd_eeee _rrrr_wwww_iiii_dddd_mmmm _ZZZZ_QQQQ Disable double wide printing _eeee_xxxx_iiii_tttt______iiii_nnnn_ssss_eeee_rrrr_tttt______mmmm_oooo_dddd_eeee _rrrr_mmmm_iiii_rrrr _eeee_iiii End insert mode _eeee_xxxx_iiii_tttt______iiii_tttt_aaaa_llll_iiii_cccc_ssss______mmmm_oooo_dddd_eeee _rrrr_iiii_tttt_mmmm _ZZZZ_RRRR Disable italics _eeee_xxxx_iiii_tttt______llll_eeee_ffff_tttt_wwww_aaaa_rrrr_dddd______mmmm_oooo_dddd_eeee _rrrr_llll_mmmm _ZZZZ_SSSS Enable rightward (normal) carriage motion _eeee_xxxx_iiii_tttt______mmmm_iiii_cccc_rrrr_oooo______mmmm_oooo_dddd_eeee _rrrr_mmmm_iiii_cccc_mmmm _ZZZZ_TTTT Disable micro motion capabilities _eeee_xxxx_iiii_tttt______pppp_cccc______cccc_hhhh_aaaa_rrrr_ssss_eeee_tttt______mmmm_oooo_dddd_eeee _rrrr_mmmm_pppp_cccc_hhhh _SSSS_3333 Disable PC character display mode _eeee_xxxx_iiii_tttt______ssss_cccc_aaaa_nnnn_cccc_oooo_dddd_eeee______mmmm_oooo_dddd_eeee _rrrr_mmmm_ssss_cccc _SSSS_5555 Disable PC scancode mode _eeee_xxxx_iiii_tttt______ssss_hhhh_aaaa_dddd_oooo_wwww______mmmm_oooo_dddd_eeee _rrrr_ssss_hhhh_mmmm _ZZZZ_UUUU Disable shadow printing _eeee_xxxx_iiii_tttt______ssss_tttt_aaaa_nnnn_dddd_oooo_uuuu_tttt______mmmm_oooo_dddd_eeee _rrrr_mmmm_ssss_oooo _ssss_eeee End standout mode _eeee_xxxx_iiii_tttt______ssss_uuuu_bbbb_ssss_cccc_rrrr_iiii_pppp_tttt______mmmm_oooo_dddd_eeee _rrrr_ssss_uuuu_bbbb_mmmm _ZZZZ_VVVV Disable subscript printing _eeee_xxxx_iiii_tttt______ssss_uuuu_pppp_eeee_rrrr_ssss_cccc_rrrr_iiii_pppp_tttt______mmmm_oooo_dddd_eeee _rrrr_ssss_uuuu_pppp_mmmm _ZZZZ_WWWW Disable superscript printing _eeee_xxxx_iiii_tttt______uuuu_nnnn_dddd_eeee_rrrr_llll_iiii_nnnn_eeee______mmmm_oooo_dddd_eeee _rrrr_mmmm_uuuu_llll _uuuu_eeee End underscore mode _eeee_xxxx_iiii_tttt______uuuu_pppp_wwww_aaaa_rrrr_dddd______mmmm_oooo_dddd_eeee _rrrr_uuuu_mmmm _ZZZZ_XXXX Enable downward (normal) PPPPaaaaggggeeee 6666 carriage motion _eeee_xxxx_iiii_tttt______xxxx_oooo_nnnn______mmmm_oooo_dddd_eeee _rrrr_mmmm_xxxx_oooo_nnnn _RRRR_XXXX Turn off xon/xoff handshaking _ffff_llll_aaaa_ssss_hhhh______ssss_cccc_rrrr_eeee_eeee_nnnn _ffff_llll_aaaa_ssss_hhhh _vvvv_bbbb Visible bell (may not move cursor) _ffff_oooo_rrrr_mmmm______ffff_eeee_eeee_dddd _ffff_ffff _ffff_ffff Hardcopy terminal page eject _ffff_rrrr_oooo_mmmm______ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee _ffff_ssss_llll _ffff_ssss Return from status line _iiii_nnnn_iiii_tttt______1111_ssss_tttt_rrrr_iiii_nnnn_gggg _iiii_ssss_1111 _iiii_1111 Terminal or printer initialization string _iiii_nnnn_iiii_tttt______2222_ssss_tttt_rrrr_iiii_nnnn_gggg _iiii_ssss_2222 _iiii_ssss Terminal or printer initialization string _iiii_nnnn_iiii_tttt______3333_ssss_tttt_rrrr_iiii_nnnn_gggg _iiii_ssss_3333 _iiii_3333 Terminal or printer initialization string _iiii_nnnn_iiii_tttt______ffff_iiii_llll_eeee _iiii_ffff _iiii_ffff Name of initialization file _iiii_nnnn_iiii_tttt______pppp_rrrr_oooo_gggg _iiii_pppp_rrrr_oooo_gggg _iiii_PPPP Path name of program for initialization _iiii_nnnn_iiii_tttt_iiii_aaaa_llll_iiii_zzzz_eeee______cccc_oooo_llll_oooo_rrrr _iiii_nnnn_iiii_tttt_cccc _IIII_cccc Initialize the definition of color _iiii_nnnn_iiii_tttt_iiii_aaaa_llll_iiii_zzzz_eeee______pppp_aaaa_iiii_rrrr _iiii_nnnn_iiii_tttt_pppp _IIII_pppp Initialize color-pair _iiii_nnnn_ssss_eeee_rrrr_tttt______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr _iiii_cccc_hhhh_1111 _iiii_cccc Insert character _iiii_nnnn_ssss_eeee_rrrr_tttt______llll_iiii_nnnn_eeee _iiii_llll_1111 _aaaa_llll Add new blank line _iiii_nnnn_ssss_eeee_rrrr_tttt______pppp_aaaa_dddd_dddd_iiii_nnnn_gggg _iiii_pppp _iiii_pppp Insert pad after character inserted The ``_kkkk_eeee_yyyy_____'' strings are sent by specific keys. The ``_kkkk_eeee_yyyy_____'' descriptions include the macro, defined in _cccc_uuuu_rrrr_ssss_eeee_ssss_...._hhhh, for the code returned by the _cccc_uuuu_rrrr_ssss_eeee_ssss routine _gggg_eeee_tttt_cccc_hhhh when the key is pressed [see curs_getch(3X)]. Cap- Termcap Variable name Code Description PPPPaaaaggggeeee 7777 NNNN NNNN _kkkk_eeee_yyyy______aaaa_1111 _kkkk_aaaa_1111 _KKKK_1111 _KKKK_EEEE_YYYY______AAAA_1111, upper left of keypad _kkkk_eeee_yyyy______aaaa_3333 _kkkk_aaaa_3333 _KKKK_3333 _KKKK_EEEE_YYYY______AAAA_3333, upper right of keypad _kkkk_eeee_yyyy______bbbb_2222 _kkkk_bbbb_2222 _KKKK_2222 _KKKK_EEEE_YYYY______BBBB_2222, center of keypad _kkkk_eeee_yyyy______bbbb_aaaa_cccc_kkkk_ssss_pppp_aaaa_cccc_eeee _kkkk_bbbb_ssss _kkkk_bbbb _KKKK_EEEE_YYYY______BBBB_AAAA_CCCC_KKKK_SSSS_PPPP_AAAA_CCCC_EEEE, sent by backspace key _kkkk_eeee_yyyy______bbbb_eeee_gggg _kkkk_bbbb_eeee_gggg _@@@@_1111 _KKKK_EEEE_YYYY______BBBB_EEEE_GGGG, sent by beg(inning) key _kkkk_eeee_yyyy______bbbb_tttt_aaaa_bbbb _kkkk_cccc_bbbb_tttt _kkkk_BBBB _KKKK_EEEE_YYYY______BBBB_TTTT_AAAA_BBBB, sent by back-tab key _kkkk_eeee_yyyy______cccc_1111 _kkkk_cccc_1111 _KKKK_4444 _KKKK_EEEE_YYYY______CCCC_1111, lower left of keypad _kkkk_eeee_yyyy______cccc_3333 _kkkk_cccc_3333 _KKKK_5555 _KKKK_EEEE_YYYY______CCCC_3333, lower right of keypad _kkkk_eeee_yyyy______cccc_aaaa_nnnn_cccc_eeee_llll _kkkk_cccc_aaaa_nnnn _@@@@_2222 _KKKK_EEEE_YYYY______CCCC_AAAA_NNNN_CCCC_EEEE_LLLL, sent by cancel key _kkkk_eeee_yyyy______cccc_aaaa_tttt_aaaa_bbbb _kkkk_tttt_bbbb_cccc _kkkk_aaaa _KKKK_EEEE_YYYY______CCCC_AAAA_TTTT_AAAA_BBBB, sent by clear-all-tabs key _kkkk_eeee_yyyy______cccc_llll_eeee_aaaa_rrrr _kkkk_cccc_llll_rrrr _kkkk_CCCC _KKKK_EEEE_YYYY______CCCC_LLLL_EEEE_AAAA_RRRR, sent by clear-screen or erase key _kkkk_eeee_yyyy______cccc_llll_oooo_ssss_eeee _kkkk_cccc_llll_oooo _@@@@_3333 _KKKK_EEEE_YYYY______CCCC_LLLL_OOOO_SSSS_EEEE, sent by close key _kkkk_eeee_yyyy______cccc_oooo_mmmm_mmmm_aaaa_nnnn_dddd _kkkk_cccc_mmmm_dddd _@@@@_4444 _KKKK_EEEE_YYYY______CCCC_OOOO_MMMM_MMMM_AAAA_NNNN_DDDD, sent by cmd (command) key _kkkk_eeee_yyyy______cccc_oooo_pppp_yyyy _kkkk_cccc_pppp_yyyy _@@@@_5555 _KKKK_EEEE_YYYY______CCCC_OOOO_PPPP_YYYY, sent by copy key _kkkk_eeee_yyyy______cccc_rrrr_eeee_aaaa_tttt_eeee _kkkk_cccc_rrrr_tttt _@@@@_6666 _KKKK_EEEE_YYYY______CCCC_RRRR_EEEE_AAAA_TTTT_EEEE, sent by create key _kkkk_eeee_yyyy______cccc_tttt_aaaa_bbbb _kkkk_cccc_tttt_aaaa_bbbb _kkkk_tttt _KKKK_EEEE_YYYY______CCCC_TTTT_AAAA_BBBB, sent by clear-tab key _kkkk_eeee_yyyy______dddd_cccc _kkkk_dddd_cccc_hhhh_1111 _kkkk_DDDD _KKKK_EEEE_YYYY______DDDD_CCCC, sent by delete-character key _kkkk_eeee_yyyy______dddd_llll _kkkk_dddd_llll_1111 _kkkk_LLLL _KKKK_EEEE_YYYY______DDDD_LLLL, sent by delete-line key _kkkk_eeee_yyyy______dddd_oooo_wwww_nnnn _kkkk_cccc_uuuu_dddd_1111 _kkkk_dddd _KKKK_EEEE_YYYY______DDDD_OOOO_WWWW_NNNN, sent by terminal down-arrow key _kkkk_eeee_yyyy______eeee_iiii_cccc _kkkk_rrrr_mmmm_iiii_rrrr _kkkk_MMMM _KKKK_EEEE_YYYY______EEEE_IIII_CCCC, sent by _rrrr_mmmm_iiii_rrrr or _ssss_mmmm_iiii_rrrr in insert mode _kkkk_eeee_yyyy______eeee_nnnn_dddd _kkkk_eeee_nnnn_dddd _@@@@_7777 _KKKK_EEEE_YYYY______EEEE_NNNN_DDDD, sent by end key _kkkk_eeee_yyyy______eeee_nnnn_tttt_eeee_rrrr _kkkk_eeee_nnnn_tttt _@@@@_8888 _KKKK_EEEE_YYYY______EEEE_NNNN_TTTT_EEEE_RRRR, sent by enter/send key _kkkk_eeee_yyyy______eeee_oooo_llll _kkkk_eeee_llll _kkkk_EEEE _KKKK_EEEE_YYYY______EEEE_OOOO_LLLL, sent by clear-to-end-of-line key _kkkk_eeee_yyyy______eeee_oooo_ssss _kkkk_eeee_dddd _kkkk_SSSS _KKKK_EEEE_YYYY______EEEE_OOOO_SSSS, sent by clear-to-end-of-screen key _kkkk_eeee_yyyy______eeee_xxxx_iiii_tttt _kkkk_eeee_xxxx_tttt _@@@@_9999 _KKKK_EEEE_YYYY______EEEE_XXXX_IIII_TTTT, sent by exit key _kkkk_eeee_yyyy______ffff_0000 _kkkk_ffff_0000 _kkkk_0000 _KKKK_EEEE_YYYY______FFFF_((((_0000_)))), sent by function key f0 _kkkk_eeee_yyyy______ffff_1111 _kkkk_ffff_1111 _kkkk_1111 _KKKK_EEEE_YYYY______FFFF_((((_1111_)))), sent by function key f1 _kkkk_eeee_yyyy______ffff_2222 _kkkk_ffff_2222 _kkkk_2222 _KKKK_EEEE_YYYY______FFFF_((((_2222_)))), sent by function key f2 _kkkk_eeee_yyyy______ffff_3333 _kkkk_ffff_3333 _kkkk_3333 _KKKK_EEEE_YYYY______FFFF_((((_3333_)))), sent by function key f3 _kkkk_eeee_yyyy______ffff_4444 _kkkk_ffff_4444 _kkkk_4444 _KKKK_EEEE_YYYY______FFFF_((((_4444_)))), sent by function key f4 _kkkk_eeee_yyyy______ffff_5555 _kkkk_ffff_5555 _kkkk_5555 _KKKK_EEEE_YYYY______FFFF_((((_5555_)))), sent by function key f5 _kkkk_eeee_yyyy______ffff_6666 _kkkk_ffff_6666 _kkkk_6666 _KKKK_EEEE_YYYY______FFFF_((((_6666_)))), sent by function key f6 _kkkk_eeee_yyyy______ffff_7777 _kkkk_ffff_7777 _kkkk_7777 _KKKK_EEEE_YYYY______FFFF_((((_7777_)))), sent by function key f7 _kkkk_eeee_yyyy______ffff_8888 _kkkk_ffff_8888 _kkkk_8888 _KKKK_EEEE_YYYY______FFFF_((((_8888_)))), sent by function key f8 _kkkk_eeee_yyyy______ffff_9999 _kkkk_ffff_9999 _kkkk_9999 _KKKK_EEEE_YYYY______FFFF_((((_9999_)))), sent by function key f9 _kkkk_eeee_yyyy______ffff_1111_0000 _kkkk_ffff_1111_0000 _kkkk_;;;; _KKKK_EEEE_YYYY______FFFF_((((_1111_0000_)))), sent by function key f10 _kkkk_eeee_yyyy______ffff_1111_1111 _kkkk_ffff_1111_1111 _FFFF_1111 _KKKK_EEEE_YYYY______FFFF_((((_1111_1111_)))), sent by function key f11 _kkkk_eeee_yyyy______ffff_1111_2222 _kkkk_ffff_1111_2222 _FFFF_2222 _KKKK_EEEE_YYYY______FFFF_((((_1111_2222_)))), sent by function key f12 _kkkk_eeee_yyyy______ffff_1111_3333 _kkkk_ffff_1111_3333 _FFFF_3333 _KKKK_EEEE_YYYY______FFFF_((((_1111_3333_)))), sent by function key f13 _kkkk_eeee_yyyy______ffff_1111_4444 _kkkk_ffff_1111_4444 _FFFF_4444 _KKKK_EEEE_YYYY______FFFF_((((_1111_4444_)))), sent by function key f14 _kkkk_eeee_yyyy______ffff_1111_5555 _kkkk_ffff_1111_5555 _FFFF_5555 _KKKK_EEEE_YYYY______FFFF_((((_1111_5555_)))), sent by function key f15 _kkkk_eeee_yyyy______ffff_1111_6666 _kkkk_ffff_1111_6666 _FFFF_6666 _KKKK_EEEE_YYYY______FFFF_((((_1111_6666_)))), sent by function key f16 _kkkk_eeee_yyyy______ffff_1111_7777 _kkkk_ffff_1111_7777 _FFFF_7777 _KKKK_EEEE_YYYY______FFFF_((((_1111_7777_)))), sent by function key f17 _kkkk_eeee_yyyy______ffff_1111_8888 _kkkk_ffff_1111_8888 _FFFF_8888 _KKKK_EEEE_YYYY______FFFF_((((_1111_8888_)))), sent by function key f18 PPPPaaaaggggeeee 8888 NNNN NNNN _kkkk_eeee_yyyy______ffff_1111_9999 _kkkk_ffff_1111_9999 _FFFF_9999 _KKKK_EEEE_YYYY______FFFF_((((_1111_9999_)))), sent by function key f19 _kkkk_eeee_yyyy______ffff_2222_0000 _kkkk_ffff_2222_0000 _FFFF_AAAA _KKKK_EEEE_YYYY______FFFF_((((_2222_0000_)))), sent by function key f20 _kkkk_eeee_yyyy______ffff_2222_1111 _kkkk_ffff_2222_1111 _FFFF_BBBB _KKKK_EEEE_YYYY______FFFF_((((_2222_1111_)))), sent by function key f21 _kkkk_eeee_yyyy______ffff_2222_2222 _kkkk_ffff_2222_2222 _FFFF_CCCC _KKKK_EEEE_YYYY______FFFF_((((_2222_2222_)))), sent by function key f22 _kkkk_eeee_yyyy______ffff_2222_3333 _kkkk_ffff_2222_3333 _FFFF_DDDD _KKKK_EEEE_YYYY______FFFF_((((_2222_3333_)))), sent by function key f23 _kkkk_eeee_yyyy______ffff_2222_4444 _kkkk_ffff_2222_4444 _FFFF_EEEE _KKKK_EEEE_YYYY______FFFF_((((_2222_4444_)))), sent by function key f24 _kkkk_eeee_yyyy______ffff_2222_5555 _kkkk_ffff_2222_5555 _FFFF_FFFF _KKKK_EEEE_YYYY______FFFF_((((_2222_5555_)))), sent by function key f25 _kkkk_eeee_yyyy______ffff_2222_6666 _kkkk_ffff_2222_6666 _FFFF_GGGG _KKKK_EEEE_YYYY______FFFF_((((_2222_6666_)))), sent by function key f26 _kkkk_eeee_yyyy______ffff_2222_7777 _kkkk_ffff_2222_7777 _FFFF_HHHH _KKKK_EEEE_YYYY______FFFF_((((_2222_7777_)))), sent by function key f27 _kkkk_eeee_yyyy______ffff_2222_8888 _kkkk_ffff_2222_8888 _FFFF_IIII _KKKK_EEEE_YYYY______FFFF_((((_2222_8888_)))), sent by function key f28 _kkkk_eeee_yyyy______ffff_2222_9999 _kkkk_ffff_2222_9999 _FFFF_JJJJ _KKKK_EEEE_YYYY______FFFF_((((_2222_9999_)))), sent by function key f29 _kkkk_eeee_yyyy______ffff_3333_0000 _kkkk_ffff_3333_0000 _FFFF_KKKK _KKKK_EEEE_YYYY______FFFF_((((_3333_0000_)))), sent by function key f30 _kkkk_eeee_yyyy______ffff_3333_1111 _kkkk_ffff_3333_1111 _FFFF_LLLL _KKKK_EEEE_YYYY______FFFF_((((_3333_1111_)))), sent by function key f31 _kkkk_eeee_yyyy______ffff_3333_2222 _kkkk_ffff_3333_2222 _FFFF_MMMM _KKKK_EEEE_YYYY______FFFF_((((_3333_2222_)))), sent by function key f32 _kkkk_eeee_yyyy______ffff_3333_3333 _kkkk_ffff_3333_3333 _FFFF_NNNN _KKKK_EEEE_YYYY______FFFF_((((_1111_3333_)))), sent by function key f13 _kkkk_eeee_yyyy______ffff_3333_4444 _kkkk_ffff_3333_4444 _FFFF_OOOO _KKKK_EEEE_YYYY______FFFF_((((_3333_4444_)))), sent by function key f34 _kkkk_eeee_yyyy______ffff_3333_5555 _kkkk_ffff_3333_5555 _FFFF_PPPP _KKKK_EEEE_YYYY______FFFF_((((_3333_5555_)))), sent by function key f35 _kkkk_eeee_yyyy______ffff_3333_6666 _kkkk_ffff_3333_6666 _FFFF_QQQQ _KKKK_EEEE_YYYY______FFFF_((((_3333_6666_)))), sent by function key f36 _kkkk_eeee_yyyy______ffff_3333_7777 _kkkk_ffff_3333_7777 _FFFF_RRRR _KKKK_EEEE_YYYY______FFFF_((((_3333_7777_)))), sent by function key f37 _kkkk_eeee_yyyy______ffff_3333_8888 _kkkk_ffff_3333_8888 _FFFF_SSSS _KKKK_EEEE_YYYY______FFFF_((((_3333_8888_)))), sent by function key f38 _kkkk_eeee_yyyy______ffff_3333_9999 _kkkk_ffff_3333_9999 _FFFF_TTTT _KKKK_EEEE_YYYY______FFFF_((((_3333_9999_)))), sent by function key f39 _kkkk_eeee_yyyy______ffff_4444_0000 _kkkk_ffff_4444_0000 _FFFF_UUUU _KKKK_EEEE_YYYY______FFFF_((((_4444_0000_)))), sent by function key f40 _kkkk_eeee_yyyy______ffff_4444_1111 _kkkk_ffff_4444_1111 _FFFF_VVVV _KKKK_EEEE_YYYY______FFFF_((((_4444_1111_)))), sent by function key f41 _kkkk_eeee_yyyy______ffff_4444_2222 _kkkk_ffff_4444_2222 _FFFF_WWWW _KKKK_EEEE_YYYY______FFFF_((((_4444_2222_)))), sent by function key f42 _kkkk_eeee_yyyy______ffff_4444_3333 _kkkk_ffff_4444_3333 _FFFF_XXXX _KKKK_EEEE_YYYY______FFFF_((((_4444_3333_)))), sent by function key f43 _kkkk_eeee_yyyy______ffff_4444_4444 _kkkk_ffff_4444_4444 _FFFF_YYYY _KKKK_EEEE_YYYY______FFFF_((((_4444_4444_)))), sent by function key f44 _kkkk_eeee_yyyy______ffff_4444_5555 _kkkk_ffff_4444_5555 _FFFF_ZZZZ _KKKK_EEEE_YYYY______FFFF_((((_4444_5555_)))), sent by function key f45 _kkkk_eeee_yyyy______ffff_4444_6666 _kkkk_ffff_4444_6666 _FFFF_aaaa _KKKK_EEEE_YYYY______FFFF_((((_4444_6666_)))), sent by function key f46 _kkkk_eeee_yyyy______ffff_4444_7777 _kkkk_ffff_4444_7777 _FFFF_bbbb _KKKK_EEEE_YYYY______FFFF_((((_4444_7777_)))), sent by function key f47 _kkkk_eeee_yyyy______ffff_4444_8888 _kkkk_ffff_4444_8888 _FFFF_cccc _KKKK_EEEE_YYYY______FFFF_((((_4444_8888_)))), sent by function key f48 _kkkk_eeee_yyyy______ffff_4444_9999 _kkkk_ffff_4444_9999 _FFFF_dddd _KKKK_EEEE_YYYY______FFFF_((((_4444_9999_)))), sent by function key f49 _kkkk_eeee_yyyy______ffff_5555_0000 _kkkk_ffff_5555_0000 _FFFF_eeee _KKKK_EEEE_YYYY______FFFF_((((_5555_0000_)))), sent by function key f50 _kkkk_eeee_yyyy______ffff_5555_1111 _kkkk_ffff_5555_1111 _FFFF_ffff _KKKK_EEEE_YYYY______FFFF_((((_5555_1111_)))), sent by function key f51 _kkkk_eeee_yyyy______ffff_5555_2222 _kkkk_ffff_5555_2222 _FFFF_gggg _KKKK_EEEE_YYYY______FFFF_((((_5555_2222_)))), sent by function key f52 _kkkk_eeee_yyyy______ffff_5555_3333 _kkkk_ffff_5555_3333 _FFFF_hhhh _KKKK_EEEE_YYYY______FFFF_((((_5555_3333_)))), sent by function key f53 _kkkk_eeee_yyyy______ffff_5555_4444 _kkkk_ffff_5555_4444 _FFFF_iiii _KKKK_EEEE_YYYY______FFFF_((((_5555_4444_)))), sent by function key f54 _kkkk_eeee_yyyy______ffff_5555_5555 _kkkk_ffff_5555_5555 _FFFF_jjjj _KKKK_EEEE_YYYY______FFFF_((((_5555_5555_)))), sent by function key f55 _kkkk_eeee_yyyy______ffff_5555_6666 _kkkk_ffff_5555_6666 _FFFF_kkkk _KKKK_EEEE_YYYY______FFFF_((((_5555_6666_)))), sent by function key f56 _kkkk_eeee_yyyy______ffff_5555_7777 _kkkk_ffff_5555_7777 _FFFF_llll _KKKK_EEEE_YYYY______FFFF_((((_5555_7777_)))), sent by function key f57 _kkkk_eeee_yyyy______ffff_5555_8888 _kkkk_ffff_5555_8888 _FFFF_mmmm _KKKK_EEEE_YYYY______FFFF_((((_5555_8888_)))), sent by function key f58 _kkkk_eeee_yyyy______ffff_5555_9999 _kkkk_ffff_5555_9999 _FFFF_nnnn _KKKK_EEEE_YYYY______FFFF_((((_5555_9999_)))), sent by function key f59 _kkkk_eeee_yyyy______ffff_6666_0000 _kkkk_ffff_6666_0000 _FFFF_oooo _KKKK_EEEE_YYYY______FFFF_((((_6666_0000_)))), sent by function key f60 _kkkk_eeee_yyyy______ffff_6666_1111 _kkkk_ffff_6666_1111 _FFFF_pppp _KKKK_EEEE_YYYY______FFFF_((((_6666_1111_)))), sent by function key f61 _kkkk_eeee_yyyy______ffff_6666_2222 _kkkk_ffff_6666_2222 _FFFF_qqqq _KKKK_EEEE_YYYY______FFFF_((((_6666_2222_)))), sent by function key f62 _kkkk_eeee_yyyy______ffff_6666_3333 _kkkk_ffff_6666_3333 _FFFF_rrrr _KKKK_EEEE_YYYY______FFFF_((((_6666_3333_)))), sent by function key f63 _kkkk_eeee_yyyy______ffff_iiii_nnnn_dddd _kkkk_ffff_nnnn_dddd _@@@@_0000 _KKKK_EEEE_YYYY______FFFF_IIII_NNNN_DDDD, sent by find key _kkkk_eeee_yyyy______hhhh_eeee_llll_pppp _kkkk_hhhh_llll_pppp _%%%%_1111 _KKKK_EEEE_YYYY______HHHH_EEEE_LLLL_PPPP, sent by help key _kkkk_eeee_yyyy______hhhh_oooo_mmmm_eeee _kkkk_hhhh_oooo_mmmm_eeee _kkkk_hhhh _KKKK_EEEE_YYYY______HHHH_OOOO_MMMM_EEEE, sent by home key _kkkk_eeee_yyyy______iiii_cccc _kkkk_iiii_cccc_hhhh_1111 _kkkk_IIII _KKKK_EEEE_YYYY______IIII_CCCC, sent by ins-char/enter ins-mode key PPPPaaaaggggeeee 9999 NNNN NNNN _kkkk_eeee_yyyy______iiii_llll _kkkk_iiii_llll_1111 _kkkk_AAAA _KKKK_EEEE_YYYY______IIII_LLLL, sent by insert-line key _kkkk_eeee_yyyy______llll_eeee_ffff_tttt _kkkk_cccc_uuuu_bbbb_1111 _kkkk_llll _KKKK_EEEE_YYYY______LLLL_EEEE_FFFF_TTTT, sent by terminal left-arrow key _kkkk_eeee_yyyy______llll_llll _kkkk_llll_llll _kkkk_HHHH _KKKK_EEEE_YYYY______LLLL_LLLL, sent by home-down key _kkkk_eeee_yyyy______mmmm_aaaa_rrrr_kkkk _kkkk_mmmm_rrrr_kkkk _%%%%_2222 _KKKK_EEEE_YYYY______MMMM_AAAA_RRRR_KKKK, sent by mark key _kkkk_eeee_yyyy______mmmm_eeee_ssss_ssss_aaaa_gggg_eeee _kkkk_mmmm_ssss_gggg _%%%%_3333 _KKKK_EEEE_YYYY______MMMM_EEEE_SSSS_SSSS_AAAA_GGGG_EEEE, sent by message key _kkkk_eeee_yyyy______mmmm_oooo_vvvv_eeee _kkkk_mmmm_oooo_vvvv _%%%%_4444 _KKKK_EEEE_YYYY______MMMM_OOOO_VVVV_EEEE, sent by move key _kkkk_eeee_yyyy______nnnn_eeee_xxxx_tttt _kkkk_nnnn_xxxx_tttt _%%%%_5555 _KKKK_EEEE_YYYY______NNNN_EEEE_XXXX_TTTT, sent by next-object key _kkkk_eeee_yyyy______nnnn_pppp_aaaa_gggg_eeee _kkkk_nnnn_pppp _kkkk_NNNN _KKKK_EEEE_YYYY______NNNN_PPPP_AAAA_GGGG_EEEE, sent by next-page key _kkkk_eeee_yyyy______oooo_pppp_eeee_nnnn _kkkk_oooo_pppp_nnnn _%%%%_6666 _KKKK_EEEE_YYYY______OOOO_PPPP_EEEE_NNNN, sent by open key _kkkk_eeee_yyyy______oooo_pppp_tttt_iiii_oooo_nnnn_ssss _kkkk_oooo_pppp_tttt _%%%%_7777 _KKKK_EEEE_YYYY______OOOO_PPPP_TTTT_IIII_OOOO_NNNN_SSSS, sent by options key _kkkk_eeee_yyyy______pppp_pppp_aaaa_gggg_eeee _kkkk_pppp_pppp _kkkk_PPPP _KKKK_EEEE_YYYY______PPPP_PPPP_AAAA_GGGG_EEEE, sent by previous-page key _kkkk_eeee_yyyy______pppp_rrrr_eeee_vvvv_iiii_oooo_uuuu_ssss _kkkk_pppp_rrrr_vvvv _%%%%_8888 _KKKK_EEEE_YYYY______PPPP_RRRR_EEEE_VVVV_IIII_OOOO_UUUU_SSSS, sent by previous-object key _kkkk_eeee_yyyy______pppp_rrrr_iiii_nnnn_tttt _kkkk_pppp_rrrr_tttt _%%%%_9999 _KKKK_EEEE_YYYY______PPPP_RRRR_IIII_NNNN_TTTT, sent by print or copy key _kkkk_eeee_yyyy______rrrr_eeee_dddd_oooo _kkkk_rrrr_dddd_oooo _%%%%_0000 _KKKK_EEEE_YYYY______RRRR_EEEE_DDDD_OOOO, sent by redo key _kkkk_eeee_yyyy______rrrr_eeee_ffff_eeee_rrrr_eeee_nnnn_cccc_eeee _kkkk_rrrr_eeee_ffff _&&&&_1111 _KKKK_EEEE_YYYY______RRRR_EEEE_FFFF_EEEE_RRRR_EEEE_NNNN_CCCC_EEEE, sent by ref(erence) key _kkkk_eeee_yyyy______rrrr_eeee_ffff_rrrr_eeee_ssss_hhhh _kkkk_rrrr_ffff_rrrr _&&&&_2222 _KKKK_EEEE_YYYY______RRRR_EEEE_FFFF_RRRR_EEEE_SSSS_HHHH, sent by refresh key _kkkk_eeee_yyyy______rrrr_eeee_pppp_llll_aaaa_cccc_eeee _kkkk_rrrr_pppp_llll _&&&&_3333 _KKKK_EEEE_YYYY______RRRR_EEEE_PPPP_LLLL_AAAA_CCCC_EEEE, sent by replace key _kkkk_eeee_yyyy______rrrr_eeee_ssss_tttt_aaaa_rrrr_tttt _kkkk_rrrr_ssss_tttt _&&&&_4444 _KKKK_EEEE_YYYY______RRRR_EEEE_SSSS_TTTT_AAAA_RRRR_TTTT, sent by restart key _kkkk_eeee_yyyy______rrrr_eeee_ssss_uuuu_mmmm_eeee _kkkk_rrrr_eeee_ssss _&&&&_5555 _KKKK_EEEE_YYYY______RRRR_EEEE_SSSS_UUUU_MMMM_EEEE, sent by resume key _kkkk_eeee_yyyy______rrrr_iiii_gggg_hhhh_tttt _kkkk_cccc_uuuu_ffff_1111 _kkkk_rrrr _KKKK_EEEE_YYYY______RRRR_IIII_GGGG_HHHH_TTTT, sent by terminal right-arrow key _kkkk_eeee_yyyy______ssss_aaaa_vvvv_eeee _kkkk_ssss_aaaa_vvvv _&&&&_6666 _KKKK_EEEE_YYYY______SSSS_AAAA_VVVV_EEEE, sent by save key _kkkk_eeee_yyyy______ssss_bbbb_eeee_gggg _kkkk_BBBB_EEEE_GGGG _&&&&_9999 _KKKK_EEEE_YYYY______SSSS_BBBB_EEEE_GGGG, sent by shifted beginning key _kkkk_eeee_yyyy______ssss_cccc_aaaa_nnnn_cccc_eeee_llll _kkkk_CCCC_AAAA_NNNN _&&&&_0000 _KKKK_EEEE_YYYY______SSSS_CCCC_AAAA_NNNN_CCCC_EEEE_LLLL, sent by shifted cancel key _kkkk_eeee_yyyy______ssss_cccc_oooo_mmmm_mmmm_aaaa_nnnn_dddd _kkkk_CCCC_MMMM_DDDD _****_1111 _KKKK_EEEE_YYYY______SSSS_CCCC_OOOO_MMMM_MMMM_AAAA_NNNN_DDDD, sent by shifted command key _kkkk_eeee_yyyy______ssss_cccc_oooo_pppp_yyyy _kkkk_CCCC_PPPP_YYYY _****_2222 _KKKK_EEEE_YYYY______SSSS_CCCC_OOOO_PPPP_YYYY, sent by shifted copy key _kkkk_eeee_yyyy______ssss_cccc_rrrr_eeee_aaaa_tttt_eeee _kkkk_CCCC_RRRR_TTTT _****_3333 _KKKK_EEEE_YYYY______SSSS_CCCC_RRRR_EEEE_AAAA_TTTT_EEEE, sent by shifted create key _kkkk_eeee_yyyy______ssss_dddd_cccc _kkkk_DDDD_CCCC _****_4444 _KKKK_EEEE_YYYY______SSSS_DDDD_CCCC, sent by shifted delete-char key _kkkk_eeee_yyyy______ssss_dddd_llll _kkkk_DDDD_LLLL _****_5555 _KKKK_EEEE_YYYY______SSSS_DDDD_LLLL, sent by shifted delete-line key _kkkk_eeee_yyyy______ssss_eeee_llll_eeee_cccc_tttt _kkkk_ssss_llll_tttt _****_6666 _KKKK_EEEE_YYYY______SSSS_EEEE_LLLL_EEEE_CCCC_TTTT, sent by select key _kkkk_eeee_yyyy______ssss_eeee_nnnn_dddd _kkkk_EEEE_NNNN_DDDD _****_7777 _KKKK_EEEE_YYYY______SSSS_EEEE_NNNN_DDDD, sent by shifted end key _kkkk_eeee_yyyy______ssss_eeee_oooo_llll _kkkk_EEEE_OOOO_LLLL _****_8888 _KKKK_EEEE_YYYY______SSSS_EEEE_OOOO_LLLL, sent by shifted clear-line key _kkkk_eeee_yyyy______ssss_eeee_xxxx_iiii_tttt _kkkk_EEEE_XXXX_TTTT _****_9999 _KKKK_EEEE_YYYY______SSSS_EEEE_XXXX_IIII_TTTT, sent by shifted exit key _kkkk_eeee_yyyy______ssss_ffff _kkkk_iiii_nnnn_dddd _kkkk_FFFF _KKKK_EEEE_YYYY______SSSS_FFFF, sent by scroll-forward/down key _kkkk_eeee_yyyy______ssss_ffff_iiii_nnnn_dddd _kkkk_FFFF_NNNN_DDDD _****_0000 _KKKK_EEEE_YYYY______SSSS_FFFF_IIII_NNNN_DDDD, sent by shifted find key _kkkk_eeee_yyyy______ssss_hhhh_eeee_llll_pppp _kkkk_HHHH_LLLL_PPPP _####_1111 _KKKK_EEEE_YYYY______SSSS_HHHH_EEEE_LLLL_PPPP, sent by shifted help key _kkkk_eeee_yyyy______ssss_hhhh_oooo_mmmm_eeee _kkkk_HHHH_OOOO_MMMM _####_2222 _KKKK_EEEE_YYYY______SSSS_HHHH_OOOO_MMMM_EEEE, sent by shifted home key _kkkk_eeee_yyyy______ssss_iiii_cccc _kkkk_IIII_CCCC _####_3333 _KKKK_EEEE_YYYY______SSSS_IIII_CCCC, sent by shifted input key _kkkk_eeee_yyyy______ssss_llll_eeee_ffff_tttt _kkkk_LLLL_FFFF_TTTT _####_4444 _KKKK_EEEE_YYYY______SSSS_LLLL_EEEE_FFFF_TTTT, sent by shifted left-arrow key _kkkk_eeee_yyyy______ssss_mmmm_eeee_ssss_ssss_aaaa_gggg_eeee _kkkk_MMMM_SSSS_GGGG _%%%%_aaaa _KKKK_EEEE_YYYY______SSSS_MMMM_EEEE_SSSS_SSSS_AAAA_GGGG_EEEE, sent by shifted message key _kkkk_eeee_yyyy______ssss_mmmm_oooo_vvvv_eeee _kkkk_MMMM_OOOO_VVVV _%%%%_bbbb _KKKK_EEEE_YYYY______SSSS_MMMM_OOOO_VVVV_EEEE, sent by shifted move key _kkkk_eeee_yyyy______ssss_nnnn_eeee_xxxx_tttt _kkkk_NNNN_XXXX_TTTT _%%%%_cccc _KKKK_EEEE_YYYY______SSSS_NNNN_EEEE_XXXX_TTTT, sent by shifted next key _kkkk_eeee_yyyy______ssss_oooo_pppp_tttt_iiii_oooo_nnnn_ssss _kkkk_OOOO_PPPP_TTTT _%%%%_dddd _KKKK_EEEE_YYYY______SSSS_OOOO_PPPP_TTTT_IIII_OOOO_NNNN_SSSS, sent by shifted options key PPPPaaaaggggeeee 11110000 NNNN NNNN _kkkk_eeee_yyyy______ssss_pppp_rrrr_eeee_vvvv_iiii_oooo_uuuu_ssss _kkkk_PPPP_RRRR_VVVV _%%%%_eeee _KKKK_EEEE_YYYY______SSSS_PPPP_RRRR_EEEE_VVVV_IIII_OOOO_UUUU_SSSS, sent by shifted prev key _kkkk_eeee_yyyy______ssss_pppp_rrrr_iiii_nnnn_tttt _kkkk_PPPP_RRRR_TTTT _%%%%_ffff _KKKK_EEEE_YYYY______SSSS_PPPP_RRRR_IIII_NNNN_TTTT, sent by shifted print key _kkkk_eeee_yyyy______ssss_rrrr _kkkk_rrrr_iiii _kkkk_RRRR _KKKK_EEEE_YYYY______SSSS_RRRR, sent by scroll-backward/up key _kkkk_eeee_yyyy______ssss_rrrr_eeee_dddd_oooo _kkkk_RRRR_DDDD_OOOO _%%%%_gggg _KKKK_EEEE_YYYY______SSSS_RRRR_EEEE_DDDD_OOOO, sent by shifted redo key _kkkk_eeee_yyyy______ssss_rrrr_eeee_pppp_llll_aaaa_cccc_eeee _kkkk_RRRR_PPPP_LLLL _%%%%_hhhh _KKKK_EEEE_YYYY______SSSS_RRRR_EEEE_PPPP_LLLL_AAAA_CCCC_EEEE, sent by shifted replace key _kkkk_eeee_yyyy______ssss_rrrr_iiii_gggg_hhhh_tttt _kkkk_RRRR_IIII_TTTT _%%%%_iiii _KKKK_EEEE_YYYY______SSSS_RRRR_IIII_GGGG_HHHH_TTTT, sent by shifted right-arrow key _kkkk_eeee_yyyy______ssss_rrrr_ssss_uuuu_mmmm_eeee _kkkk_RRRR_EEEE_SSSS _%%%%_jjjj _KKKK_EEEE_YYYY______SSSS_RRRR_SSSS_UUUU_MMMM_EEEE, sent by shifted resume key _kkkk_eeee_yyyy______ssss_ssss_aaaa_vvvv_eeee _kkkk_SSSS_AAAA_VVVV _!!!!_1111 _KKKK_EEEE_YYYY______SSSS_SSSS_AAAA_VVVV_EEEE, sent by shifted save key _kkkk_eeee_yyyy______ssss_ssss_uuuu_ssss_pppp_eeee_nnnn_dddd _kkkk_SSSS_PPPP_DDDD _!!!!_2222 _KKKK_EEEE_YYYY______SSSS_SSSS_UUUU_SSSS_PPPP_EEEE_NNNN_DDDD, sent by shifted suspend key _kkkk_eeee_yyyy______ssss_tttt_aaaa_bbbb _kkkk_hhhh_tttt_ssss _kkkk_TTTT _KKKK_EEEE_YYYY______SSSS_TTTT_AAAA_BBBB, sent by set-tab key _kkkk_eeee_yyyy______ssss_uuuu_nnnn_dddd_oooo _kkkk_UUUU_NNNN_DDDD _!!!!_3333 _KKKK_EEEE_YYYY______SSSS_UUUU_NNNN_DDDD_OOOO, sent by shifted undo key _kkkk_eeee_yyyy______ssss_uuuu_ssss_pppp_eeee_nnnn_dddd _kkkk_ssss_pppp_dddd _&&&&_7777 _KKKK_EEEE_YYYY______SSSS_UUUU_SSSS_PPPP_EEEE_NNNN_DDDD, sent by suspend key _kkkk_eeee_yyyy______uuuu_nnnn_dddd_oooo _kkkk_uuuu_nnnn_dddd _&&&&_8888 _KKKK_EEEE_YYYY______UUUU_NNNN_DDDD_OOOO, sent by undo key _kkkk_eeee_yyyy______uuuu_pppp _kkkk_cccc_uuuu_uuuu_1111 _kkkk_uuuu _KKKK_EEEE_YYYY______UUUU_PPPP, sent by terminal up-arrow key _kkkk_eeee_yyyy_pppp_aaaa_dddd______llll_oooo_cccc_aaaa_llll _rrrr_mmmm_kkkk_xxxx _kkkk_eeee Out of ``keypad-transmit'' mode _kkkk_eeee_yyyy_pppp_aaaa_dddd______xxxx_mmmm_iiii_tttt _ssss_mmmm_kkkk_xxxx _kkkk_ssss Put terminal in ``keypad-transmit'' mode _llll_aaaa_bbbb______ffff_0000 _llll_ffff_0000 _llll_0000 Labels on function key f0 if not f0 _llll_aaaa_bbbb______ffff_1111 _llll_ffff_1111 _llll_1111 Labels on function key f1 if not f1 _llll_aaaa_bbbb______ffff_2222 _llll_ffff_2222 _llll_2222 Labels on function key f2 if not f2 _llll_aaaa_bbbb______ffff_3333 _llll_ffff_3333 _llll_3333 Labels on function key f3 if not f3 _llll_aaaa_bbbb______ffff_4444 _llll_ffff_4444 _llll_4444 Labels on function key f4 if not f4 _llll_aaaa_bbbb______ffff_5555 _llll_ffff_5555 _llll_5555 Labels on function key f5 if not f5 _llll_aaaa_bbbb______ffff_6666 _llll_ffff_6666 _llll_6666 Labels on function key f6 if not f6 _llll_aaaa_bbbb______ffff_7777 _llll_ffff_7777 _llll_7777 Labels on function key f7 if not f7 _llll_aaaa_bbbb______ffff_8888 _llll_ffff_8888 _llll_8888 Labels on function key f8 if not f8 _llll_aaaa_bbbb______ffff_9999 _llll_ffff_9999 _llll_9999 Labels on function key f9 if not f9 _llll_aaaa_bbbb______ffff_1111_0000 _llll_ffff_1111_0000 _llll_aaaa Labels on function key f10 if not f10 _llll_aaaa_bbbb_eeee_llll______oooo_ffff_ffff _rrrr_mmmm_llll_nnnn _LLLL_FFFF Turn off soft labels _llll_aaaa_bbbb_eeee_llll______oooo_nnnn _ssss_mmmm_llll_nnnn _LLLL_OOOO Turn on soft labels _mmmm_eeee_tttt_aaaa______oooo_ffff_ffff _rrrr_mmmm_mmmm _mmmm_oooo Turn off "meta mode" _mmmm_eeee_tttt_aaaa______oooo_nnnn _ssss_mmmm_mmmm _mmmm_mmmm Turn on "meta mode" (8th bit) _mmmm_iiii_cccc_rrrr_oooo______cccc_oooo_llll_uuuu_mmmm_nnnn______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _mmmm_hhhh_pppp_aaaa _ZZZZ_YYYY Like _cccc_oooo_llll_uuuu_mmmm_nnnn______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss for micro adjustment _mmmm_iiii_cccc_rrrr_oooo______dddd_oooo_wwww_nnnn _mmmm_cccc_uuuu_dddd_1111 _ZZZZ_ZZZZ Like _cccc_uuuu_rrrr_ssss_oooo_rrrr______dddd_oooo_wwww_nnnn for micro adjustment _mmmm_iiii_cccc_rrrr_oooo______llll_eeee_ffff_tttt _mmmm_cccc_uuuu_bbbb_1111 _ZZZZ_aaaa Like _cccc_uuuu_rrrr_ssss_oooo_rrrr______llll_eeee_ffff_tttt for micro adjustment _mmmm_iiii_cccc_rrrr_oooo______rrrr_iiii_gggg_hhhh_tttt _mmmm_cccc_uuuu_ffff_1111 _ZZZZ_bbbb Like _cccc_uuuu_rrrr_ssss_oooo_rrrr______rrrr_iiii_gggg_hhhh_tttt for micro adjustment _mmmm_iiii_cccc_rrrr_oooo______rrrr_oooo_wwww______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _mmmm_vvvv_pppp_aaaa _ZZZZ_cccc Like _rrrr_oooo_wwww______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss for micro adjustment _mmmm_iiii_cccc_rrrr_oooo______uuuu_pppp _mmmm_cccc_uuuu_uuuu_1111 _ZZZZ_dddd Like _cccc_uuuu_rrrr_ssss_oooo_rrrr______uuuu_pppp for micro adjustment _nnnn_eeee_wwww_llll_iiii_nnnn_eeee _nnnn_eeee_llll _nnnn_wwww Newline (behaves like _cccc_rrrr followed by _llll_ffff) _oooo_rrrr_dddd_eeee_rrrr______oooo_ffff______pppp_iiii_nnnn_ssss _pppp_oooo_rrrr_dddd_eeee_rrrr _ZZZZ_eeee Matches software bits to print-head pins _oooo_rrrr_iiii_gggg______cccc_oooo_llll_oooo_rrrr_ssss _oooo_cccc _oooo_cccc Set all color(-pair)s to the original ones PPPPaaaaggggeeee 11111111 NNNN NNNN _oooo_rrrr_iiii_gggg______pppp_aaaa_iiii_rrrr _oooo_pppp _oooo_pppp Set default color-pair to the original one _pppp_aaaa_dddd______cccc_hhhh_aaaa_rrrr _pppp_aaaa_dddd _pppp_cccc Pad character (rather than null) _pppp_aaaa_rrrr_mmmm______dddd_cccc_hhhh _dddd_cccc_hhhh _DDDD_CCCC Delete #1 chars _pppp_aaaa_rrrr_mmmm______dddd_eeee_llll_eeee_tttt_eeee______llll_iiii_nnnn_eeee _dddd_llll _DDDD_LLLL Delete #1 lines _pppp_aaaa_rrrr_mmmm______dddd_oooo_wwww_nnnn______cccc_uuuu_rrrr_ssss_oooo_rrrr _cccc_uuuu_dddd _DDDD_OOOO Move down #1 lines. _pppp_aaaa_rrrr_mmmm______dddd_oooo_wwww_nnnn______mmmm_iiii_cccc_rrrr_oooo _mmmm_cccc_uuuu_dddd _ZZZZ_ffff Like _pppp_aaaa_rrrr_mmmm______dddd_oooo_wwww_nnnn______cccc_uuuu_rrrr_ssss_oooo_rrrr for micro adjust. _pppp_aaaa_rrrr_mmmm______iiii_cccc_hhhh _iiii_cccc_hhhh _IIII_CCCC Insert #1 blank chars _pppp_aaaa_rrrr_mmmm______iiii_nnnn_dddd_eeee_xxxx _iiii_nnnn_dddd_nnnn _SSSS_FFFF Scroll forward #1 lines. _pppp_aaaa_rrrr_mmmm______iiii_nnnn_ssss_eeee_rrrr_tttt______llll_iiii_nnnn_eeee _iiii_llll _AAAA_LLLL Add #1 new blank lines _pppp_aaaa_rrrr_mmmm______llll_eeee_ffff_tttt______cccc_uuuu_rrrr_ssss_oooo_rrrr _cccc_uuuu_bbbb _LLLL_EEEE Move cursor left #1 spaces _pppp_aaaa_rrrr_mmmm______llll_eeee_ffff_tttt______mmmm_iiii_cccc_rrrr_oooo _mmmm_cccc_uuuu_bbbb _ZZZZ_gggg Like _pppp_aaaa_rrrr_mmmm______llll_eeee_ffff_tttt______cccc_uuuu_rrrr_ssss_oooo_rrrr for micro adjust. _pppp_aaaa_rrrr_mmmm______rrrr_iiii_gggg_hhhh_tttt______cccc_uuuu_rrrr_ssss_oooo_rrrr _cccc_uuuu_ffff _RRRR_IIII Move right #1 spaces. _pppp_aaaa_rrrr_mmmm______rrrr_iiii_gggg_hhhh_tttt______mmmm_iiii_cccc_rrrr_oooo _mmmm_cccc_uuuu_ffff _ZZZZ_hhhh Like _pppp_aaaa_rrrr_mmmm______rrrr_iiii_gggg_hhhh_tttt______cccc_uuuu_rrrr_ssss_oooo_rrrr for micro adjust. _pppp_aaaa_rrrr_mmmm______rrrr_iiii_nnnn_dddd_eeee_xxxx _rrrr_iiii_nnnn _SSSS_RRRR Scroll backward #1 lines. _pppp_aaaa_rrrr_mmmm______uuuu_pppp______cccc_uuuu_rrrr_ssss_oooo_rrrr _cccc_uuuu_uuuu _UUUU_PPPP Move cursor up #1 lines. _pppp_aaaa_rrrr_mmmm______uuuu_pppp______mmmm_iiii_cccc_rrrr_oooo _mmmm_cccc_uuuu_uuuu _ZZZZ_iiii Like _pppp_aaaa_rrrr_mmmm______uuuu_pppp______cccc_uuuu_rrrr_ssss_oooo_rrrr for micro adjust. _pppp_cccc______tttt_eeee_rrrr_mmmm______oooo_pppp_tttt_iiii_oooo_nnnn_ssss _pppp_cccc_tttt_rrrr_mmmm _SSSS_6666 PC terminal options _pppp_kkkk_eeee_yyyy______kkkk_eeee_yyyy _pppp_ffff_kkkk_eeee_yyyy _pppp_kkkk Prog funct key #1 to type string #2 _pppp_kkkk_eeee_yyyy______llll_oooo_cccc_aaaa_llll _pppp_ffff_llll_oooo_cccc _pppp_llll Prog funct key #1 to execute string #2 _pppp_kkkk_eeee_yyyy______pppp_llll_aaaa_bbbb _pppp_ffff_xxxx_llll _xxxx_llll Prog key #1 to xmit string #2 and show string #3 _pppp_kkkk_eeee_yyyy______xxxx_mmmm_iiii_tttt _pppp_ffff_xxxx _pppp_xxxx Prog funct key #1 to xmit string #2 _pppp_llll_aaaa_bbbb______nnnn_oooo_rrrr_mmmm _pppp_llll_nnnn _pppp_nnnn Prog label #1 to show string #2 _pppp_rrrr_iiii_nnnn_tttt______ssss_cccc_rrrr_eeee_eeee_nnnn _mmmm_cccc_0000 _pppp_ssss Print contents of the screen _pppp_rrrr_tttt_rrrr______nnnn_oooo_nnnn _mmmm_cccc_5555_pppp _pppp_OOOO Turn on the printer for #1 bytes _pppp_rrrr_tttt_rrrr______oooo_ffff_ffff _mmmm_cccc_4444 _pppp_ffff Turn off the printer _pppp_rrrr_tttt_rrrr______oooo_nnnn _mmmm_cccc_5555 _pppp_oooo Turn on the printer _rrrr_eeee_pppp_eeee_aaaa_tttt______cccc_hhhh_aaaa_rrrr _rrrr_eeee_pppp _rrrr_pppp Repeat char #1 #2 times _rrrr_eeee_qqqq______ffff_oooo_rrrr______iiii_nnnn_pppp_uuuu_tttt _rrrr_ffff_iiii _RRRR_FFFF Send next input char (for ptys) _rrrr_eeee_ssss_eeee_tttt______1111_ssss_tttt_rrrr_iiii_nnnn_gggg _rrrr_ssss_1111 _rrrr_1111 Reset terminal completely to sane modes _rrrr_eeee_ssss_eeee_tttt______2222_ssss_tttt_rrrr_iiii_nnnn_gggg _rrrr_ssss_2222 _rrrr_2222 Reset terminal completely to sane modes _rrrr_eeee_ssss_eeee_tttt______3333_ssss_tttt_rrrr_iiii_nnnn_gggg _rrrr_ssss_3333 _rrrr_3333 Reset terminal completely to sane modes _rrrr_eeee_ssss_eeee_tttt______ffff_iiii_llll_eeee _rrrr_ffff _rrrr_ffff Name of file containing reset string _rrrr_eeee_ssss_tttt_oooo_rrrr_eeee______cccc_uuuu_rrrr_ssss_oooo_rrrr _rrrr_cccc _rrrr_cccc Restore cursor to position of last sc _rrrr_oooo_wwww______aaaa_dddd_dddd_rrrr_eeee_ssss_ssss _vvvv_pppp_aaaa _cccc_vvvv Vertical position absolute _ssss_aaaa_vvvv_eeee______cccc_uuuu_rrrr_ssss_oooo_rrrr _ssss_cccc _ssss_cccc Save cursor position _ssss_cccc_aaaa_nnnn_cccc_oooo_dddd_eeee______eeee_ssss_cccc_aaaa_pppp_eeee _ssss_cccc_eeee_ssss_cccc _SSSS_7777 Escape for scancode emulation _ssss_cccc_rrrr_oooo_llll_llll______ffff_oooo_rrrr_wwww_aaaa_rrrr_dddd _iiii_nnnn_dddd _ssss_ffff Scroll text up _ssss_cccc_rrrr_oooo_llll_llll______rrrr_eeee_vvvv_eeee_rrrr_ssss_eeee _rrrr_iiii _ssss_rrrr Scroll text down _ssss_eeee_llll_eeee_cccc_tttt______cccc_hhhh_aaaa_rrrr______ssss_eeee_tttt _ssss_cccc_ssss _ZZZZ_jjjj Select character set _ssss_eeee_tttt_0000______dddd_eeee_ssss______ssss_eeee_qqqq _ssss_0000_dddd_ssss _ssss_0000 Shift into codeset 0 (EUC set 0, ASCII) _ssss_eeee_tttt_1111______dddd_eeee_ssss______ssss_eeee_qqqq _ssss_1111_dddd_ssss _ssss_1111 Shift into codeset 1 _ssss_eeee_tttt_2222______dddd_eeee_ssss______ssss_eeee_qqqq _ssss_2222_dddd_ssss _ssss_2222 Shift into codeset 2 _ssss_eeee_tttt_3333______dddd_eeee_ssss______ssss_eeee_qqqq _ssss_3333_dddd_ssss _ssss_3333 Shift into codeset 3 _ssss_eeee_tttt______aaaa______bbbb_aaaa_cccc_kkkk_gggg_rrrr_oooo_uuuu_nnnn_dddd _ssss_eeee_tttt_aaaa_bbbb _AAAA_BBBB Set background color using ANSI escape _ssss_eeee_tttt______aaaa______ffff_oooo_rrrr_eeee_gggg_rrrr_oooo_uuuu_nnnn_dddd _ssss_eeee_tttt_aaaa_ffff _AAAA_FFFF Set foreground color using ANSI escape _ssss_eeee_tttt______aaaa_tttt_tttt_rrrr_iiii_bbbb_uuuu_tttt_eeee_ssss _ssss_gggg_rrrr _ssss_aaaa Define the video attributes #1-#9 _ssss_eeee_tttt______bbbb_aaaa_cccc_kkkk_gggg_rrrr_oooo_uuuu_nnnn_dddd _ssss_eeee_tttt_bbbb _SSSS_bbbb Set current background color PPPPaaaaggggeeee 11112222 NNNN NNNN _ssss_eeee_tttt______bbbb_oooo_tttt_tttt_oooo_mmmm______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_bbbb _ZZZZ_kkkk Set bottom margin at current line _ssss_eeee_tttt______bbbb_oooo_tttt_tttt_oooo_mmmm______mmmm_aaaa_rrrr_gggg_iiii_nnnn______pppp_aaaa_rrrr_mmmm _ssss_mmmm_gggg_bbbb_pppp _ZZZZ_llll Set bottom margin at line #1 or #2 lines from bottom _ssss_eeee_tttt______cccc_oooo_llll_oooo_rrrr______bbbb_aaaa_nnnn_dddd _ssss_eeee_tttt_cccc_oooo_llll_oooo_rrrr_YYYY_zzzz Change to ribbon color #1 _ssss_eeee_tttt______cccc_oooo_llll_oooo_rrrr______pppp_aaaa_iiii_rrrr _ssss_cccc_pppp _ssss_pppp Set current color-pair _ssss_eeee_tttt______ffff_oooo_rrrr_eeee_gggg_rrrr_oooo_uuuu_nnnn_dddd _ssss_eeee_tttt_ffff _SSSS_ffff Set current foreground color1 _ssss_eeee_tttt______llll_eeee_ffff_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_llll _MMMM_LLLL Set left margin at current line _ssss_eeee_tttt______llll_eeee_ffff_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn______pppp_aaaa_rrrr_mmmm _ssss_mmmm_gggg_llll_pppp _ZZZZ_mmmm Set left (right) margin at column #1 (#2) _ssss_eeee_tttt______llll_rrrr______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_llll_rrrr _MMMM_LLLL Sets both left and right margins _ssss_eeee_tttt______pppp_aaaa_gggg_eeee______llll_eeee_nnnn_gggg_tttt_hhhh _ssss_llll_iiii_nnnn_eeee_ssss _YYYY_ZZZZ Set page length to #1 lines (use tparm) _ssss_eeee_tttt______pppp_gggg_llll_eeee_nnnn______iiii_nnnn_cccc_hhhh _ssss_llll_eeee_nnnn_gggg_tttt_hhhh _YYYY_IIII Set page length to #1 hundredths of an inch (use tparm) _ssss_eeee_tttt______rrrr_iiii_gggg_hhhh_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_rrrr _MMMM_RRRR Set right margin at current column _ssss_eeee_tttt______rrrr_iiii_gggg_hhhh_tttt______mmmm_aaaa_rrrr_gggg_iiii_nnnn______pppp_aaaa_rrrr_mmmm _ssss_mmmm_gggg_rrrr_pppp _ZZZZ_nnnn Set right margin at column #1 _ssss_eeee_tttt______tttt_aaaa_bbbb _hhhh_tttt_ssss _ssss_tttt Set a tab in all rows, current column _ssss_eeee_tttt______tttt_bbbb______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_tttt_bbbb _MMMM_TTTT Sets both top and bottom margins _ssss_eeee_tttt______tttt_oooo_pppp______mmmm_aaaa_rrrr_gggg_iiii_nnnn _ssss_mmmm_gggg_tttt _ZZZZ_oooo Set top margin at current line _ssss_eeee_tttt______tttt_oooo_pppp______mmmm_aaaa_rrrr_gggg_iiii_nnnn______pppp_aaaa_rrrr_mmmm _ssss_mmmm_gggg_tttt_pppp _ZZZZ_pppp Set top (bottom) margin at line #1 (#2) _ssss_eeee_tttt______wwww_iiii_nnnn_dddd_oooo_wwww _wwww_iiii_nnnn_dddd _wwww_iiii Current window is lines #1-#2 cols #3-#4 _ssss_tttt_aaaa_rrrr_tttt______bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee _ssss_bbbb_iiii_mmmm _ZZZZ_qqqq Start printing bit image graphics _ssss_tttt_aaaa_rrrr_tttt______cccc_hhhh_aaaa_rrrr______ssss_eeee_tttt______dddd_eeee_ffff _ssss_cccc_ssss_dddd _ZZZZ_rrrr Start definition of a character set _ssss_tttt_oooo_pppp______bbbb_iiii_tttt______iiii_mmmm_aaaa_gggg_eeee _rrrr_bbbb_iiii_mmmm _ZZZZ_ssss End printing bit image graphics _ssss_tttt_oooo_pppp______cccc_hhhh_aaaa_rrrr______ssss_eeee_tttt______dddd_eeee_ffff _rrrr_cccc_ssss_dddd _ZZZZ_tttt End definition of a character set _ssss_uuuu_bbbb_ssss_cccc_rrrr_iiii_pppp_tttt______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr_ssss _ssss_uuuu_bbbb_cccc_ssss _ZZZZ_uuuu List of ``subscript-able'' characters _ssss_uuuu_pppp_eeee_rrrr_ssss_cccc_rrrr_iiii_pppp_tttt______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr_ssss _ssss_uuuu_pppp_cccc_ssss _ZZZZ_vvvv List of ``superscript-able'' characters _tttt_aaaa_bbbb _hhhh_tttt _tttt_aaaa Tab to next 8-space hardware tab stop _tttt_hhhh_eeee_ssss_eeee______cccc_aaaa_uuuu_ssss_eeee______cccc_rrrr _dddd_oooo_cccc_rrrr _ZZZZ_wwww Printing any of these chars causes _cccc_rrrr _tttt_oooo______ssss_tttt_aaaa_tttt_uuuu_ssss______llll_iiii_nnnn_eeee _tttt_ssss_llll _tttt_ssss Go to status line, col #1 _uuuu_nnnn_dddd_eeee_rrrr_llll_iiii_nnnn_eeee______cccc_hhhh_aaaa_rrrr _uuuu_cccc _uuuu_cccc Underscore one char and move past it _uuuu_pppp______hhhh_aaaa_llll_ffff______llll_iiii_nnnn_eeee _hhhh_uuuu _hhhh_uuuu Half-line up (reverse 1/2 linefeed) _xxxx_oooo_ffff_ffff______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr _xxxx_oooo_ffff_ffff_cccc _XXXX_FFFF X-off character _xxxx_oooo_nnnn______cccc_hhhh_aaaa_rrrr_aaaa_cccc_tttt_eeee_rrrr _xxxx_oooo_nnnn_cccc _XXXX_NNNN X-on character _zzzz_eeee_rrrr_oooo______mmmm_oooo_tttt_iiii_oooo_nnnn _zzzz_eeee_rrrr_oooo_mmmm _ZZZZ_xxxx No motion for the subsequent character SSSSaaaammmmpppplllleeee EEEEnnnnttttrrrryyyy The following entry, which describes the AT&T 610 terminal, is among the more complex entries in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo file as of this writing. _6666_1111_0000_||||_6666_1111_0000_bbbb_cccc_tttt_||||_AAAA_TTTT_TTTT_6666_1111_0000_||||_aaaa_tttt_tttt_6666_1111_0000_||||_AAAA_TTTT_&&&&_TTTT_6666_1111_0000_;;;;_8888_0000_cccc_oooo_llll_uuuu_mmmm_nnnn_;;;;_9999_8888_kkkk_eeee_yyyy _kkkk_eeee_yyyy_bbbb_oooo_aaaa_rrrr_dddd _aaaa_mmmm_,,,, _eeee_ssss_llll_oooo_kkkk_,,,, _hhhh_ssss_,,,, _mmmm_iiii_rrrr_,,,, _mmmm_ssss_gggg_rrrr_,,,, _xxxx_eeee_nnnn_llll_,,,, _xxxx_oooo_nnnn_,,,, _cccc_oooo_llll_ssss_####_8888_0000_,,,, _iiii_tttt_####_8888_,,,, _llll_hhhh_####_2222_,,,, _llll_iiii_nnnn_eeee_ssss_####_2222_4444_,,,, _llll_wwww_####_8888_,,,, _nnnn_llll_aaaa_bbbb_####_8888_,,,, _wwww_ssss_llll_####_8888_0000_,,,, _aaaa_cccc_ssss_cccc_====_````_````_aaaa_aaaa_ffff_ffff_gggg_gggg_jjjj_jjjj_kkkk_kkkk_llll_llll_mmmm_mmmm_nnnn_nnnn_oooo_oooo_pppp_pppp_qqqq_qqqq_rrrr_rrrr_ssss_ssss_tttt_tttt_uuuu_uuuu_vvvv_vvvv_wwww_wwww_xxxx_xxxx_yyyy_yyyy_zzzz_zzzz_{{{{_{{{{_||||_||||_}}}}_}}}}_~~~~_~~~~_,,,, _bbbb_eeee_llll_====_^^^^_GGGG_,,,, _bbbb_llll_iiii_nnnn_kkkk_====_\\\\_EEEE_[[[[_5555_mmmm_,,,, _bbbb_oooo_llll_dddd_====_\\\\_EEEE_[[[[_1111_mmmm_,,,, _cccc_bbbb_tttt_====_\\\\_EEEE_[[[[_ZZZZ_,,,, _cccc_iiii_vvvv_iiii_ssss_====_\\\\_EEEE_[[[[_????_2222_5555_llll_,,,, _cccc_llll_eeee_aaaa_rrrr_====_\\\\_EEEE_[[[[_HHHH_\\\\_EEEE_[[[[_JJJJ_,,,, _cccc_nnnn_oooo_rrrr_mmmm_====_\\\\_EEEE_[[[[_????_2222_5555_hhhh_\\\\_EEEE_[[[[_????_1111_2222_llll_,,,, _cccc_rrrr_====_\\\\_rrrr_,,,, _cccc_ssss_rrrr_====_\\\\_EEEE_[[[[_%%%%_iiii_%%%%_pppp_1111_%%%%_dddd_;;;;_%%%%_pppp_2222_%%%%_dddd_rrrr_,,,, _cccc_uuuu_bbbb_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_DDDD_,,,, _cccc_uuuu_bbbb_1111_====_\\\\_bbbb_,,,, _cccc_uuuu_dddd_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_BBBB_,,,, _cccc_uuuu_dddd_1111_====_\\\\_EEEE_[[[[_BBBB_,,,, _cccc_uuuu_ffff_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_CCCC_,,,, _cccc_uuuu_ffff_1111_====_\\\\_EEEE_[[[[_CCCC_,,,, _cccc_uuuu_pppp_====_\\\\_EEEE_[[[[_%%%%_iiii_%%%%_pppp_1111_%%%%_dddd_;;;;_%%%%_pppp_2222_%%%%_dddd_HHHH_,,,, _cccc_uuuu_uuuu_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_AAAA_,,,, _cccc_uuuu_uuuu_1111_====_\\\\_EEEE_[[[[_AAAA_,,,, _cccc_vvvv_vvvv_iiii_ssss_====_\\\\_EEEE_[[[[_????_1111_2222_;;;;_2222_5555_hhhh_,,,, _dddd_cccc_hhhh_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_PPPP_,,,, _dddd_cccc_hhhh_1111_====_\\\\_EEEE_[[[[_PPPP_,,,, _dddd_iiii_mmmm_====_\\\\_EEEE_[[[[_2222_mmmm_,,,, _dddd_llll_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_MMMM_,,,, _dddd_llll_1111_====_\\\\_EEEE_[[[[_MMMM_,,,, _eeee_dddd_====_\\\\_EEEE_[[[[_JJJJ_,,,, _eeee_llll_====_\\\\_EEEE_[[[[_KKKK_,,,, _eeee_llll_1111_====_\\\\_EEEE_[[[[_1111_KKKK_,,,, _ffff_llll_aaaa_ssss_hhhh_====_\\\\_EEEE_[[[[_????_5555_hhhh_$$$$_<<<<_2222_0000_0000_>>>>_\\\\_EEEE_[[[[_????_5555_llll_,,,, _ffff_ssss_llll_====_\\\\_EEEE_8888_,,,, _hhhh_oooo_mmmm_eeee_====_\\\\_EEEE_[[[[_HHHH_,,,, _hhhh_tttt_====_\\\\_tttt_,,,, _iiii_cccc_hhhh_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_@@@@_,,,, _iiii_llll_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_LLLL_,,,, _iiii_llll_1111_====_\\\\_EEEE_[[[[_LLLL_,,,, _iiii_nnnn_dddd_====_\\\\_EEEE_DDDD_,,,, _...._iiii_nnnn_dddd_====_\\\\_EEEE_DDDD_$$$$_<<<<_9999_>>>>_,,,, _iiii_nnnn_vvvv_iiii_ssss_====_\\\\_EEEE_[[[[_8888_mmmm_,,,, _iiii_ssss_1111_====_\\\\_EEEE_[[[[_8888_;;;;_0000 _|||| _\\\\_EEEE_[[[[_????_3333_;;;;_4444_;;;;_5555_;;;;_1111_3333_;;;;_1111_5555_llll_\\\\_EEEE_[[[[_1111_3333_;;;;_2222_0000_llll_\\\\_EEEE_[[[[_????_7777_hhhh_\\\\_EEEE_[[[[_1111_2222_hhhh_\\\\_EEEE_((((_BBBB_\\\\_EEEE_))))_0000_,,,, PPPPaaaaggggeeee 11113333 NNNN NNNN _iiii_ssss_2222_====_\\\\_EEEE_[[[[_0000_mmmm_^^^^_OOOO_,,,, _iiii_ssss_3333_====_\\\\_EEEE_((((_BBBB_\\\\_EEEE_))))_0000_,,,, _kkkk_LLLL_FFFF_TTTT_====_\\\\_EEEE_[[[[_\\\\_ssss_@@@@_,,,, _kkkk_RRRR_IIII_TTTT_====_\\\\_EEEE_[[[[_\\\\_ssss_AAAA_,,,, _kkkk_bbbb_ssss_====_^^^^_HHHH_,,,, _kkkk_cccc_bbbb_tttt_====_\\\\_EEEE_[[[[_ZZZZ_,,,, _kkkk_cccc_llll_rrrr_====_\\\\_EEEE_[[[[_2222_JJJJ_,,,, _kkkk_cccc_uuuu_bbbb_1111_====_\\\\_EEEE_[[[[_DDDD_,,,, _kkkk_cccc_uuuu_dddd_1111_====_\\\\_EEEE_[[[[_BBBB_,,,, _kkkk_cccc_uuuu_ffff_1111_====_\\\\_EEEE_[[[[_CCCC_,,,, _kkkk_cccc_uuuu_uuuu_1111_====_\\\\_EEEE_[[[[_AAAA_,,,, _kkkk_ffff_1111_====_\\\\_EEEE_OOOO_cccc_,,,, _kkkk_ffff_1111_0000_====_\\\\_EEEE_NNNN_pppp_,,,, _kkkk_ffff_1111_1111_====_\\\\_EEEE_NNNN_qqqq_,,,, _kkkk_ffff_1111_2222_====_\\\\_EEEE_NNNN_rrrr_,,,, _kkkk_ffff_1111_3333_====_\\\\_EEEE_NNNN_ssss_,,,, _kkkk_ffff_1111_4444_====_\\\\_EEEE_NNNN_tttt_,,,, _kkkk_ffff_2222_====_\\\\_EEEE_OOOO_dddd_,,,, _kkkk_ffff_3333_====_\\\\_EEEE_OOOO_eeee_,,,, _kkkk_ffff_4444_====_\\\\_EEEE_OOOO_ffff_,,,, _kkkk_ffff_5555_====_\\\\_EEEE_OOOO_gggg_,,,, _kkkk_ffff_6666_====_\\\\_EEEE_OOOO_hhhh_,,,, _kkkk_ffff_7777_====_\\\\_EEEE_OOOO_iiii_,,,, _kkkk_ffff_8888_====_\\\\_EEEE_OOOO_jjjj_,,,, _kkkk_ffff_9999_====_\\\\_EEEE_NNNN_oooo_,,,, _kkkk_hhhh_oooo_mmmm_eeee_====_\\\\_EEEE_[[[[_HHHH_,,,, _kkkk_iiii_nnnn_dddd_====_\\\\_EEEE_[[[[_SSSS_,,,, _kkkk_rrrr_iiii_====_\\\\_EEEE_[[[[_TTTT_,,,, _llll_llll_====_\\\\_EEEE_[[[[_2222_4444_HHHH_,,,, _mmmm_cccc_4444_====_\\\\_EEEE_[[[[_????_4444_iiii_,,,, _mmmm_cccc_5555_====_\\\\_EEEE_[[[[_????_5555_iiii_,,,, _nnnn_eeee_llll_====_\\\\_EEEE_EEEE_,,,, _pppp_ffff_xxxx_llll_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_;;;;_%%%%_pppp_2222_%%%%_llll_%%%%_0000_2222_dddd_qqqq_%%%%_????_%%%%_pppp_1111_%%%%_{{{{_9999_}}}}_%%%%_<<<<_%%%%_tttt_\\\\_ssss_\\\\_ssss_\\\\_ssss_FFFF_%%%%_pppp_1111_%%%%_1111_dddd_\\\\_ssss_\\\\_ssss_\\\\_ssss_\\\\_ssss_\\\\_ssss _\\\\_ssss_\\\\_ssss_\\\\_ssss_\\\\_ssss_\\\\_ssss_\\\\_ssss_%%%%_;;;;_%%%%_pppp_2222_%%%%_ssss_,,,, _pppp_llll_nnnn_====_\\\\_EEEE_[[[[_%%%%_pppp_1111_%%%%_dddd_;;;;_0000_;;;;_0000_;;;;_0000_qqqq_%%%%_pppp_2222_%%%%_::::_----_1111_6666_...._1111_6666_ssss_,,,, _rrrr_cccc_====_\\\\_EEEE_8888_,,,, _rrrr_eeee_vvvv_====_\\\\_EEEE_[[[[_7777_mmmm_,,,, _rrrr_iiii_====_\\\\_EEEE_MMMM_,,,, _rrrr_mmmm_aaaa_cccc_ssss_====_^^^^_OOOO_,,,, _rrrr_mmmm_iiii_rrrr_====_\\\\_EEEE_[[[[_4444_llll_,,,, _rrrr_mmmm_llll_nnnn_====_\\\\_EEEE_[[[[_2222_pppp_,,,, _rrrr_mmmm_ssss_oooo_====_\\\\_EEEE_[[[[_mmmm_,,,, _rrrr_mmmm_uuuu_llll_====_\\\\_EEEE_[[[[_mmmm_,,,, _rrrr_ssss_2222_====_\\\\_EEEE_cccc_\\\\_EEEE_[[[[_????_3333_llll_,,,, _ssss_cccc_====_\\\\_EEEE_7777_,,,, _ssss_gggg_rrrr_====_\\\\_EEEE_[[[[_0000_%%%%_????_%%%%_pppp_6666_%%%%_tttt_;;;;_1111_%%%%_;;;;_%%%%_????_%%%%_pppp_5555_%%%%_tttt_;;;;_2222_%%%%_;;;;_%%%%_????_%%%%_pppp_2222_%%%%_tttt_;;;;_4444_%%%%_;;;;_%%%%_????_%%%%_pppp_4444_%%%%_tttt_;;;;_5555_%%%%_;;;; _%%%%_????_%%%%_pppp_3333_%%%%_pppp_1111_%%%% _|||| _%%%%_tttt_;;;;_7777_%%%%_;;;;_%%%%_????_%%%%_pppp_7777_%%%%_tttt_;;;;_8888_%%%%_;;;;_mmmm_%%%%_????_%%%%_pppp_9999_%%%%_tttt_^^^^_NNNN_%%%%_eeee_^^^^_OOOO_%%%%_;;;;_,,,, _ssss_gggg_rrrr_0000_====_\\\\_EEEE_[[[[_mmmm_^^^^_OOOO_,,,, _ssss_mmmm_aaaa_cccc_ssss_====_^^^^_NNNN_,,,, _ssss_mmmm_iiii_rrrr_====_\\\\_EEEE_[[[[_4444_hhhh_,,,, _ssss_mmmm_llll_nnnn_====_\\\\_EEEE_[[[[_pppp_,,,, _ssss_mmmm_ssss_oooo_====_\\\\_EEEE_[[[[_7777_mmmm_,,,, _ssss_mmmm_uuuu_llll_====_\\\\_EEEE_[[[[_4444_mmmm_,,,, _tttt_ssss_llll_====_\\\\_EEEE_7777_\\\\_EEEE_[[[[_2222_5555_;;;;_%%%%_iiii_%%%%_pppp_1111_%%%%_dddd_xxxx_,,,, TTTTyyyyppppeeeessss ooooffff CCCCaaaappppaaaabbbbiiiilllliiiittttiiiieeeessss iiiinnnn tttthhhheeee SSSSaaaammmmpppplllleeee EEEEnnnnttttrrrryyyy The sample entry shows the formats for the three types of _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo capabilities listed: Boolean, numeric, and string. All capabilities specified in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file must be followed by commas, including the last capability in the source file. In _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source files, capabilities are referenced by their capability names (as shown in the previous tables). Boolean capabilities are specified simply by their comma separated cap names. Numeric capabilities are followed by the character `#' and then a positive integer value. Thus, in the sample, _cccc_oooo_llll_ssss (which shows the number of columns available on a device) is assigned the value _8888_0000 for the AT&T 610. (Values for numeric capabilities may be specified in decimal, octal, or hexadecimal, using normal C programming language conventions.) Finally, string-valued capabilities such as _eeee_llll (clear to end of line sequence) are listed by a two- to five-character capname, an `=', and a string ended by the next occurrence of a comma. A delay in milliseconds may appear anywhere in such a capability, preceded by _$$$$ and enclosed in angle brackets, as in _eeee_llll_====_\\\\_EEEE_KKKK_$$$$_<<<<_3333_>>>>. Padding characters are supplied by _tttt_pppp_uuuu_tttt. The delay can be any of the following: a number, a number followed by an asterisk, such as _5555_****, a number followed by a slash, such as _5555_////, or a number followed by both, such as _5555_****_////. A `_****_'''' shows that the padding required is proportional to the number of lines affected by the operation, and the amount given is the per-affected-unit padding required. (In the case of insert characters, the factor is still the number of lines affected. This is always 1 unless the device has _iiii_nnnn and the software uses it.) When a `_****_'''' is specified, it is sometimes useful to give a delay of the form _3333_...._5555 to specify a delay per unit to tenths of milliseconds. (Only one decimal place is allowed.) PPPPaaaaggggeeee 11114444 NNNN NNNN A `/' indicates that the padding is mandatory. If a device has _xxxx_oooo_nnnn defined, the padding information is advisory and will only be used for cost estimates or when the device is in raw mode. Mandatory padding will be transmitted regardless of the setting of _xxxx_oooo_nnnn. If padding (whether advisory or mandatory) is specified for _bbbb_eeee_llll or _ffff_llll_aaaa_ssss_hhhh, however, it will always be used, regardless of whether _xxxx_oooo_nnnn is specified. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo offers notation for encoding special characters. Both _\\\\_EEEE and _\\\\_eeee map to an ESCAPE character, ^_x maps to a control _x for any appropriate _x, and the sequences _\\\\_nnnn_,,,, _\\\\_llll_,,,, _\\\\_rrrr_,,,, _\\\\_tttt_,,,, _\\\\_bbbb_,,,, _\\\\_ffff, and _\\\\_ssss give a newline, linefeed, return, tab, backspace, formfeed, and space, respectively. Other escapes include: _\\\\_^^^^ for caret (^); _\\\\_\\\\ for backslash (\); _\\\\, for comma (,); _\\\\_:::: for colon (:); and _\\\\_0000 for null. (_\\\\_0000 will actually produce _\\\\_2222_0000_0000, which does not terminate a string but behaves as a null character on most devices, providing CS7 is specified. [See _ssss_tttt_tttt_yyyy(1).] Finally, characters may be given as three octal digits after a backslash (for example, \123). Sometimes individual capabilities must be commented out. To do this, put a period before the capability name. For example, see the second _iiii_nnnn_dddd in the example above. Note that capabilities are defined in a left-to-right order and, therefore, a prior definition will override a later definition. PPPPrrrreeeeppppaaaarrrriiiinnnngggg DDDDeeeessssccccrrrriiiippppttttiiiioooonnnnssss The most effective way to prepare a device description is by imitating the description of a similar device in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo and building up a description gradually, using partial descriptions with _vvvv_iiii to check that they are correct. Be aware that a very unusual device may expose deficiencies in the ability of the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo file to describe it or the inability of _vvvv_iiii to work with that device. To test a new device description, set the environment variable _TTTT_EEEE_RRRR_MMMM_IIII_NNNN_FFFF_OOOO to the pathname of a directory containing the compiled description you are working on and programs will look there rather than in _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo. To get the padding for insert-line correct (if the device manufacturer did not document it) a severe test is to comment out _xxxx_oooo_nnnn, edit a large file at 9600 baud with _vvvv_iiii, delete 16 or so lines from the middle of the screen, and then press the _uuuu key several times quickly. If the display is corrupted, more padding is usually needed. A similar test can be used for insert-character. SSSSeeeeccccttttiiiioooonnnn 1111----1111:::: BBBBaaaassssiiiicccc CCCCaaaappppaaaabbbbiiiilllliiiittttiiiieeeessss The number of columns on each line for the device is given by the _cccc_oooo_llll_ssss numeric capability. If the device has a screen, then the number of lines on the screen is given by the _llll_iiii_nnnn_eeee_ssss capability. If the device wraps around to the beginning of the next line when it reaches the right margin, then it should have the _aaaa_mmmm capability. If the terminal can clear its screen, leaving the cursor in the home position, then this is given by the _cccc_llll_eeee_aaaa_rrrr string capability. If the terminal overstrikes (rather than clearing a position when a character is struck over) then it should have the _oooo_ssss capability. If the device is a printing terminal, with no soft copy unit, specify both _hhhh_cccc and _oooo_ssss. If there is a way to move the cursor PPPPaaaaggggeeee 11115555 NNNN NNNN to the left edge of the current row, specify this as _cccc_rrrr. (Normally this will be carriage return, control M.) If there is a way to produce an audible signal (such as a bell or a beep), specify it as _bbbb_eeee_llll. If, like most devices, the device uses the xon-xoff flow-control protocol, specify _xxxx_oooo_nnnn. If there is a way to move the cursor one position to the left (such as backspace), that capability should be given as _cccc_uuuu_bbbb_1111. Similarly, sequences to move to the right, up, and down should be given as _cccc_uuuu_ffff_1111, _cccc_uuuu_uuuu_1111, and _cccc_uuuu_dddd_1111, respectively. These local cursor motions must not alter the text they pass over; for example, you would not normally use ``_cccc_uuuu_ffff_1111=\s'' because the space would erase the character moved over. A very important point here is that the local cursor motions encoded in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo are undefined at the left and top edges of a screen terminal. Programs should never attempt to backspace around the left edge, unless _bbbb_wwww is specified, and should never attempt to go up locally off the top. To scroll text up, a program goes to the bottom left corner of the screen and sends the _iiii_nnnn_dddd (index) string. To scroll text down, a program goes to the top left corner of the screen and sends the _rrrr_iiii (reverse index) string. The strings _iiii_nnnn_dddd and _rrrr_iiii are undefined when not on their respective corners of the screen. Parameterized versions of the scrolling sequences are _iiii_nnnn_dddd_nnnn and _rrrr_iiii_nnnn. These versions have the same semantics as _iiii_nnnn_dddd and _rrrr_iiii, except that they take one parameter and scroll the number of lines specified by that parameter. They are also undefined except at the appropriate edge of the screen. The _aaaa_mmmm capability tells whether the cursor sticks at the right edge of the screen when text is output, but this does not necessarily apply to a _cccc_uuuu_ffff_1111 from the last column. Backward motion from the left edge of the screen is possible only when _bbbb_wwww is specified. In this case, _cccc_uuuu_bbbb_1111 will move to the right edge of the previous row. If _bbbb_wwww is not given, the effect is undefined. This is useful for drawing a box around the edge of the screen, for example. If the device has switch selectable automatic margins, _aaaa_mmmm should be specified in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo source file. In this case, initialization strings should turn on this option, if possible. If the device has a command that moves to the first column of the next line, that command can be given as _nnnn_eeee_llll (newline). It does not matter if the command clears the remainder of the current line, so if the device has no _cccc_rrrr and _llll_ffff it may still be possible to craft a working _nnnn_eeee_llll out of one or both of them. These capabilities suffice to describe hardcopy and screen terminals. Thus the AT&T 5320 hardcopy terminal is described as follows: _5555_3333_2222_0000_||||_aaaa_tttt_tttt_5555_3333_2222_0000_||||_AAAA_TTTT_&&&&_TTTT _5555_3333_2222_0000 _hhhh_aaaa_rrrr_dddd_cccc_oooo_pppp_yyyy _tttt_eeee_rrrr_mmmm_iiii_nnnn_aaaa_llll_,,,, _aaaa_mmmm_,,,, _hhhh_cccc_,,,, _oooo_ssss_,,,, _cccc_oooo_llll_ssss_####_1111_3333_2222_,,,, _bbbb_eeee_llll_====_^^^^_GGGG_,,,, _cccc_rrrr_====_\\\\_rrrr_,,,, _cccc_uuuu_bbbb_1111_====_\\\\_bbbb_,,,, _cccc_nnnn_dddd_1111_====_\\\\_nnnn_,,,, PPPPaaaaggggeeee 11116666 NNNN NNNN _dddd_cccc_hhhh_1111_====_\\\\_EEEE_[[[[_PPPP_,,,, _dddd_llll_1111_====_\\\\_EEEE_[[[[_MMMM_,,,, _iiii_nnnn_dddd_====_\\\\_nnnn_,,,, while the Lear Siegler ADM-3 is described as _aaaa_dddd_mmmm_3333_||||_llll_ssss_iiii _aaaa_dddd_mmmm_3333_,,,, _aaaa_mmmm_,,,, _bbbb_eeee_llll_====_^^^^_GGGG_,,,, _cccc_llll_eeee_aaaa_rrrr_====_^^^^_ZZZZ_,,,, _cccc_oooo_llll_ssss_####_8888_0000_,,,, _cccc_rrrr_====_^^^^_MMMM_,,,, _cccc_uuuu_bbbb_1111_====_^^^^_HHHH_,,,, _cccc_uuuu_dddd_1111_====_^^^^_JJJJ_,,,, _iiii_nnnn_dddd_====_^^^^_JJJJ_,,,, _llll_iiii_nnnn_eeee_ssss_####_2222_4444, SSSSeeeeccccttttiiiioooonnnn 1111----2222:::: PPPPaaaarrrraaaammmmeeeetttteeeerrrriiiizzzzeeeedddd SSSSttttrrrriiiinnnnggggssss Cursor addressing and other strings requiring parameters are described by a parameterized string capability, with _pppp_rrrr_iiii_nnnn_tttt_ffff-like escapes (_%%%%_x) in it. For example, to address the cursor, the _cccc_uuuu_pppp capability is given, using two parameters: the row and column to address to. (Rows and columns are numbered from zero and refer to the physical screen visible to the user, not to any unseen memory.) If the terminal has memory relative cursor addressing, that can be indicated by _mmmm_rrrr_cccc_uuuu_pppp. The parameter mechanism uses a stack and special _%%%% codes to manipulate the stack in the manner of Reverse Polish Notation (postfix). Typically a sequence will push one of the parameters onto the stack and then print it in some format. Often more complex operations are necessary. Operations are in postfix form with the operands in the usual order. That is, to subtract 5 from the first parameter, one would use _%%%%_pppp_1111_%%%%_{{{{_5555_}}}}_%%%%_----. The _%%%% encodings have the following meanings: _%%%%_%%%% outputs `%' _%%%%_[[[[_[[[[_::::_]]]]_f_l_a_g_s][_w_i_d_t_h[._p_r_e_c_i_s_i_o_n]][_dddd_oooo_xxxx_XXXX_ssss] as in _pppp_rrrr_iiii_nnnn_tttt_ffff, flags are _[[[[_----_++++_####_]]]] and space _%%%%_cccc print pop gives %c _%%%%_pppp_[[[[_1111_----_9999_]]]] push _ith parm _%%%%_PPPP_[[[[_aaaa_----_zzzz_]]]] set dynamic variable [a-z] to pop _%%%%_gggg_[[[[_aaaa_----_zzzz_]]]] get dynamic variable [a-z] and push it _%%%%_PPPP_[[[[_AAAA_----_ZZZZ_]]]] set static variable [a-z] to pop _%%%%_gggg_[[[[_AAAA_----_ZZZZ_]]]] get static variable [a-z] and push it _%%%%_''''_c_'''' push char constant _c PPPPaaaaggggeeee 11117777 NNNN NNNN _%%%%_{{{{_n_n_}}}} push decimal constant _n_n _%%%%_llll push strlen(pop) _%%%%_++++ _%%%%_---- _%%%%_**** _%%%%_//// _%%%%_mmmm arithmetic (_%%%%_mmmm is mod): push(pop integer op pop integer ) 2 1 _%%%%_&&&& _%%%%_|||| _%%%%_^^^^ bit operations: push(pop integer op pop integer ) 2 1 _%%%%_==== _%%%%_>>>> _%%%%_<<<< logical operations: push(pop integer op pop integer ) 2 1 _%%%%_AAAA _%%%%_OOOO logical operations: and, or _%%%%_!!!! _%%%%_~~~~ unary operations: push(op pop) _%%%%_iiii (for ANSI terminals) add 1 to first parm, if one parm present, or first two parms, if more than one parm present _%%%%_???? _e_x_p_r _%%%%_tttt _t_h_e_n_p_a_r_t _%%%%_eeee _e_l_s_e_p_a_r_t _%%%%_;;;; if-then-else, _%%%%_eeee _e_l_s_e_p_a_r_t is optional; else-if's are possible ala Algol 68: _%%%%_???? _cccc _%%%%_tttt _bbbb _%%%%_eeee _cccc _%%%%_tttt _bbbb _%%%%_eeee _cccc _%%%%_tttt _bbbb _%%%%_eeee _cccc _%%%%_tttt _bbbb _%%%%_eeee _bbbb _%%%%_;;;; c are conditio_1111ns, b _1111are b_2222odies._2222 _3333 _3333 _4444 _4444 _5555 _i _i If the ``_----'' flag is used with ``_%%%%[_dddd_oooo_xxxx_XXXX_ssss]'', then a colon (_::::) must be placed between the ``_%%%%'' and the ``_----'' to differentiate the flag from the binary ``_%%%%_----'' operator, for example, ``_%%%%_::::_----_1111_6666_...._1111_6666_ssss''. Consider the Hewlett-Packard 2645, which, to get to row 3 and column 12, needs to be sent _\\\\_EEEE_&&&&_aaaa_1111_2222_cccc_0000_3333_YYYY padded for 6 milliseconds. Note that the order of the rows and columns is inverted here, and that the row and column are zero-padded as two digits. Thus its _cccc_uuuu_pppp capability is: _cccc_uuuu_pppp_====_\\\\_EEEE_&&&&_aaaa_%%%%_pppp_2222_%%%%_2222_...._2222_dddd_cccc_%%%%_pppp_1111_%%%%_2222_...._2222_dddd_YYYY_$$$$_<<<<_6666_>>>> The Micro-Term ACT-IV needs the current row and column sent preceded by a _^^^^_TTTT, with the row and column simply encoded in binary, ``_cccc_uuuu_pppp_====_^^^^_TTTT_%%%%_pppp_1111_%%%%_cccc_%%%%_pppp_2222_%%%%_cccc''. Devices that use ``_%%%%_cccc'' need to be able to backspace the cursor (_cccc_uuuu_bbbb_1111), and to move the cursor up one line on the screen (_cccc_uuuu_uuuu_1111). This is necessary because it is not always safe to transmit _\\\\_nnnn, _^^^^_DDDD, and _\\\\_rrrr, as the system may change or discard them. (The library routines dealing with _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo set tty modes so that tabs are never expanded, so _\\\\_tttt is safe to send. This turns out to be essential for the Ann Arbor 4080.) A final example is the LSI ADM-3a, which uses row and column offset by a blank character, thus ``_cccc_uuuu_pppp_====_\\\\_EEEE_====_%%%%_pppp_1111_%%%%_''''_\\\\_ssss_''''_%%%%_++++_%%%%_cccc_%%%%_pppp_2222_%%%%_''''_\\\\_ssss_''''_%%%%_++++_%%%%_cccc''. After sending ``_\\\\_EEEE_===='', this pushes the first parameter, pushes the ASCII value for a space (32), adds them (pushing the sum on the stack in place of the two PPPPaaaaggggeeee 11118888 NNNN NNNN previous values), and outputs that value as a character. Then the same is done for the second parameter. More complex arithmetic is possible using the stack. SSSSeeeeccccttttiiiioooonnnn 1111----3333:::: CCCCuuuurrrrssssoooorrrr MMMMoooottttiiiioooonnnnssss If the terminal has a fast way to home the cursor (to very upper left corner of screen) then this can be given as _hhhh_oooo_mmmm_eeee; similarly a fast way of getting to the lower left-hand corner can be given as _llll_llll; this may involve going up with _cccc_uuuu_uuuu_1111 from the home position, but a program should never do this itself (unless _llll_llll does) because it can make no assumption about the effect of moving up from the home position. Note that the home position is the same as addressing to (0,0): to the top left corner of the screen, not of memory. (Thus, the _\\\\_EEEE_HHHH sequence on Hewlett-Packard terminals cannot be used for _hhhh_oooo_mmmm_eeee without losing some of the other features on the terminal.) If the device has row or column absolute-cursor addressing, these can be given as single parameter capabilities _hhhh_pppp_aaaa (horizontal position absolute) and _vvvv_pppp_aaaa (vertical position absolute). Sometimes these are shorter than the more general two-parameter sequence (as with the Hewlett-Packard 2645) and can be used in preference to _cccc_uuuu_pppp. If there are parameterized local motions (for example, move _n spaces to the right) these can be given as _cccc_uuuu_dddd, _cccc_uuuu_bbbb, _cccc_uuuu_ffff, and _cccc_uuuu_uuuu with a single parameter indicating how many spaces to move. These are primarily useful if the device does not have _cccc_uuuu_pppp, such as the Tektronix 4025. If the device needs to be in a special mode when running a program that uses these capabilities, the codes to enter and exit this mode can be given as _ssss_mmmm_cccc_uuuu_pppp and _rrrr_mmmm_cccc_uuuu_pppp. This arises, for example, from terminals, such as the Concept, with more than one page of memory. If the device has only memory relative cursor addressing and not screen relative cursor addressing, a one screen-sized window must be fixed into the device for cursor addressing to work properly. This is also used for the Tektronix 4025, where _ssss_mmmm_cccc_uuuu_pppp sets the command character to be the one used by _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo. If the _ssss_mmmm_cccc_uuuu_pppp sequence will not restore the screen after an _rrrr_mmmm_cccc_uuuu_pppp sequence is output (to the state prior to outputting _rrrr_mmmm_cccc_uuuu_pppp), specify _nnnn_rrrr_rrrr_mmmm_cccc. SSSSeeeeccccttttiiiioooonnnn 1111----4444:::: AAAArrrreeeeaaaa CCCClllleeeeaaaarrrrssss If the terminal can clear from the current position to the end of the line, leaving the cursor where it is, this should be given as _eeee_llll. If the terminal can clear from the beginning of the line to the current position inclusive, leaving the cursor where it is, this should be given as _eeee_llll_1111. If the terminal can clear from the current position to the end of the display, then this should be given as _eeee_dddd. _eeee_dddd is only defined from the first column of a line. (Thus, it can be simulated by a request to delete a large number of lines, if a true _eeee_dddd is not available.) SSSSeeeeccccttttiiiioooonnnn 1111----5555:::: IIIInnnnsssseeeerrrrtttt////DDDDeeeelllleeeetttteeee LLLLiiiinnnneeee If the terminal can open a new blank line before the line where the cursor is, this should be given as _iiii_llll_1111; this is done only from the first position of a line. The cursor must then appear on the newly blank line. PPPPaaaaggggeeee 11119999 NNNN NNNN If the terminal can delete the line which the cursor is on, then this should be given as _dddd_llll_1111; this is done only from the first position on the line to be deleted. Versions of _iiii_llll_1111 and _dddd_llll_1111 which take a single parameter and insert or delete that many lines can be given as _iiii_llll and _dddd_llll. If the terminal has a settable destructive scrolling region (like the VT100) the command to set this can be described with the _cccc_ssss_rrrr capability, which takes two parameters: the top and bottom lines of the scrolling region. The cursor position is, alas, undefined after using this command. It is possible to get the effect of insert or delete line using this command - the _ssss_cccc and _rrrr_cccc (save and restore cursor) commands are also useful. Inserting lines at the top or bottom of the screen can also be done using _rrrr_iiii or _iiii_nnnn_dddd on many terminals without a true insert/delete line, and is often faster even on terminals with those features. To determine whether a terminal has destructive scrolling regions or non-destructive scrolling regions, create a scrolling region in the middle of the screen, place data on the bottom line of the scrolling region, move the cursor to the top line of the scrolling region, and do a reverse index (_rrrr_iiii) followed by a delete line (_dddd_llll_1111) or index (_iiii_nnnn_dddd). If the data that was originally on the bottom line of the scrolling region was restored into the scrolling region by the _dddd_llll_1111 or _iiii_nnnn_dddd, then the terminal has non-destructive scrolling regions. Otherwise, it has destructive scrolling regions. Do not specify _cccc_ssss_rrrr if the terminal has non-destructive scrolling regions, unless _iiii_nnnn_dddd, _rrrr_iiii, _iiii_nnnn_dddd_nnnn, _rrrr_iiii_nnnn, _dddd_llll, and _dddd_llll_1111 all simulate destructive scrolling. If the terminal has the ability to define a window as part of memory, which all commands affect, it should be given as the parameterized string _wwww_iiii_nnnn_dddd. The four parameters are the starting and ending lines in memory and the starting and ending columns in memory, in that order. If the terminal can retain display memory above, then the _dddd_aaaa capability should be given; if display memory can be retained below, then _dddd_bbbb should be given. These indicate that deleting a line or scrolling a full screen may bring non-blank lines up from below or that scrolling back with _rrrr_iiii may bring down non-blank lines. SSSSeeeeccccttttiiiioooonnnn 1111----6666:::: IIIInnnnsssseeeerrrrtttt////DDDDeeeelllleeeetttteeee CCCChhhhaaaarrrraaaacccctttteeeerrrr There are two basic kinds of intelligent terminals with respect to insert/delete character operations which can be described using _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo_.... The most common insert/delete character operations affect only the characters on the current line and shift characters off the end of the line rigidly. Other terminals, such as the Concept 100 and the Perkin Elmer Owl, make a distinction between typed and untyped blanks on the screen, shifting upon an insert or delete only to an untyped blank on the screen which is either eliminated, or expanded to two untyped blanks. You can determine the kind of terminal you have by clearing the screen and then typing text separated by cursor motions. Type ``_aaaa_bbbb_cccc _dddd_eeee_ffff'' using local cursor motions (not spaces) between the _aaaa_bbbb_cccc and the _dddd_eeee_ffff. Then position the cursor before the _aaaa_bbbb_cccc and put the terminal in insert mode. If typing characters causes the rest of the line to shift rigidly PPPPaaaaggggeeee 22220000 NNNN NNNN and characters to fall off the end, then your terminal does not distinguish between blanks and untyped positions. If the _aaaa_bbbb_cccc shifts over to the _dddd_eeee_ffff which then move together around the end of the current line and onto the next as you insert, you have the second type of terminal, and should give the capability _iiii_nnnn, which stands for ``insert null.'' While these are two logically separate attributes (one line versus multiline insert mode, and special treatment of untyped spaces) we have seen no terminals whose insert mode cannot be described with the single attribute. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo can describe both terminals that have an insert mode and terminals which send a simple sequence to open a blank position on the current line. Give as _ssss_mmmm_iiii_rrrr the sequence to get into insert mode. Give as _rrrr_mmmm_iiii_rrrr the sequence to leave insert mode. Now give as _iiii_cccc_hhhh_1111 any sequence needed to be sent just before sending the character to be inserted. Most terminals with a true insert mode will not give _iiii_cccc_hhhh_1111; terminals that send a sequence to open a screen position should give it here. (If your terminal has both, insert mode is usually preferable to _iiii_cccc_hhhh_1111. Do not give both unless the terminal actually requires both to be used in combination.) If post-insert padding is needed, give this as a number of milliseconds padding in _iiii_pppp (a string option). Any other sequence which may need to be sent after an insert of a single character may also be given in _iiii_pppp. If your terminal needs both to be placed into an `insert mode' and a special code to precede each inserted character, then both _ssss_mmmm_iiii_rrrr/rmir and _iiii_cccc_hhhh_1111 can be given, and both will be used. The _iiii_cccc_hhhh capability, with one parameter, _n, will insert _n blanks. If padding is necessary between characters typed while not in insert mode, give this as a number of milliseconds padding in _rrrr_mmmm_pppp. It is occasionally necessary to move around while in insert mode to delete characters on the same line (for example, if there is a tab after the insertion position). If your terminal allows motion while in insert mode you can give the capability _mmmm_iiii_rrrr to speed up inserting in this case. Omitting _mmmm_iiii_rrrr will affect only speed. Some terminals (notably Datamedia's) must not have _mmmm_iiii_rrrr because of the way their insert mode works. Finally, you can specify _dddd_cccc_hhhh_1111 to delete a single character, _dddd_cccc_hhhh with one parameter, _n, to delete _n characters, and delete mode by giving _ssss_mmmm_dddd_cccc and _rrrr_mmmm_dddd_cccc to enter and exit delete mode (any mode the terminal needs to be placed in for _dddd_cccc_hhhh_1111 to work). A command to erase _n characters (equivalent to outputting _n blanks without moving the cursor) can be given as _eeee_cccc_hhhh with one parameter. SSSSeeeeccccttttiiiioooonnnn 1111----7777:::: HHHHiiiigggghhhhlllliiiigggghhhhttttiiiinnnngggg,,,, UUUUnnnnddddeeeerrrrlllliiiinnnniiiinnnngggg,,,, aaaannnndddd VVVViiiissssiiiibbbblllleeee BBBBeeeellllllllssss Your device may have one or more kinds of display attributes that allow you to highlight selected characters when they appear on the screen. The following display modes (shown with the names by which they are set) may be available: a blinking screen (_bbbb_llll_iiii_nnnn_kkkk), bold or extra-bright characters (_bbbb_oooo_llll_dddd), dim or half-bright characters (_dddd_iiii_mmmm), blanking or invisible text PPPPaaaaggggeeee 22221111 NNNN NNNN (_iiii_nnnn_vvvv_iiii_ssss), protected text (_pppp_rrrr_oooo_tttt), a reverse-video screen (_rrrr_eeee_vvvv), and an alternate character set (_ssss_mmmm_aaaa_cccc_ssss to enter this mode and _rrrr_mmmm_aaaa_cccc_ssss to exit it). (If a command is necessary before you can enter alternate character set mode, give the sequence in _eeee_nnnn_aaaa_cccc_ssss or "enable alternate-character-set" mode.) Turning on any of these modes singly may or may not turn off other modes. _ssss_gggg_rrrr_0000 should be used to turn off all video enhancement capabilities. It should always be specified because it represents the only way to turn off some capabilities, such as _dddd_iiii_mmmm or _bbbb_llll_iiii_nnnn_kkkk. You should choose one display method as _s_t_a_n_d_o_u_t _m_o_d_e [see _cccc_uuuu_rrrr_ssss_eeee_ssss(3X)] and use it to highlight error messages and other kinds of text to which you want to draw attention. Choose a form of display that provides strong contrast but that is easy on the eyes. (We recommend reverse- video plus half-bright or reverse-video alone.) The sequences to enter and exit standout mode are given as _ssss_mmmm_ssss_oooo and _rrrr_mmmm_ssss_oooo, respectively. If the code to change into or out of standout mode leaves one or even two blank spaces on the screen, as the TVI 912 and Teleray 1061 do, then _xxxx_mmmm_cccc should be given to tell how many spaces are left. Sequences to begin underlining and end underlining can be specified as _ssss_mmmm_uuuu_llll and _rrrr_mmmm_uuuu_llll _,,,, respectively. If the device has a sequence to underline the current character and to move the cursor one space to the right (such as the Micro-Term MIME), this sequence can be specified as _uuuu_cccc. Terminals with the ``magic cookie'' glitch (_xxxx_mmmm_cccc_)))) deposit special ``cookies'' when they receive mode-setting sequences, which affect the display algorithm rather than having extra bits for each character. Some terminals, such as the Hewlett-Packard 2621, automatically leave standout mode when they move to a new line or the cursor is addressed. Programs using standout mode should exit standout mode before moving the cursor or sending a newline, unless the _mmmm_ssss_gggg_rrrr capability, asserting that it is safe to move in standout mode, is present. If the terminal has a way of flashing the screen to indicate an error quietly (a bell replacement), then this can be given as _ffff_llll_aaaa_ssss_hhhh; it must not move the cursor. A good flash can be done by changing the screen into reverse video, pad for 200 ms, then return the screen to normal video. If the cursor needs to be made more visible than normal when it is not on the bottom line (to make, for example, a non-blinking underline into an easier to find block or blinking underline) give this sequence as _cccc_vvvv_vvvv_iiii_ssss. The boolean _cccc_hhhh_tttt_ssss should also be given. If there is a way to make the cursor completely invisible, give that as _cccc_iiii_vvvv_iiii_ssss. The capability _cccc_nnnn_oooo_rrrr_mmmm should be given which undoes the effects of either of these modes. If your terminal generates underlined characters by using the underline character (with no special sequences needed) even though it does not otherwise overstrike characters, then you should specify the capability _uuuu_llll. For devices on which a character overstriking another leaves both PPPPaaaaggggeeee 22222222 NNNN NNNN characters on the screen, specify the capability _oooo_ssss. If overstrikes are erasable with a blank, then this should be indicated by specifying _eeee_oooo. If there is a sequence to set arbitrary combinations of modes, this should be given as _ssss_gggg_rrrr (set attributes), taking nine parameters. Each parameter is either _0000 or non-zero, as the corresponding attribute is on or off. The nine parameters are, in order: standout, underline, reverse, blink, dim, bold, blank, protect, alternate character set. Not all modes need to be supported by _ssss_gggg_rrrr; only those for which corresponding separate attribute commands exist should be supported. For example, let's assume that the terminal in question needs the following escape sequences to turn on various modes. tparm parameter attribute escape sequence none _\\\\_EEEE_[[[[_0000_mmmm _pppp_1111 standout _\\\\_EEEE_[[[[_0000_;;;;_4444_;;;;_7777_mmmm _pppp_2222 underline _\\\\_EEEE_[[[[_0000_;;;;_3333_mmmm _pppp_3333 reverse _\\\\_EEEE_[[[[_0000_;;;;_4444_mmmm _pppp_4444 blink _\\\\_EEEE_[[[[_0000_;;;;_5555_mmmm _pppp_5555 dim _\\\\_EEEE_[[[[_0000_;;;;_7777_mmmm _pppp_6666 bold _\\\\_EEEE_[[[[_0000_;;;;_3333_;;;;_4444_mmmm _pppp_7777 invis _\\\\_EEEE_[[[[_0000_;;;;_8888_mmmm _pppp_8888 protect not available _pppp_9999 altcharset _^^^^_OOOO (off) _^^^^_NNNN (on) Note that each escape sequence requires a _0000 to turn off other modes before turning on its own mode. Also note that, as suggested above, _s_t_a_n_d_o_u_t is set up to be the combination of _r_e_v_e_r_s_e and _d_i_m. Also, because this terminal has no _b_o_l_d mode, _b_o_l_d is set up as the combination of _r_e_v_e_r_s_e and _u_n_d_e_r_l_i_n_e. In addition, to allow combinations, such as _u_n_d_e_r_l_i_n_e+_b_l_i_n_k, the sequence to use would be _\\\\_EEEE_[[[[_0000_;;;;_3333_;;;;_5555_mmmm. The terminal doesn't have _p_r_o_t_e_c_t mode, either, but that cannot be simulated in any way, so _pppp_8888 is ignored. The _a_l_t_c_h_a_r_s_e_t mode is different in that it is either _^^^^_OOOO or _^^^^_NNNN, depending on whether it is off or on. If all modes were to be turned on, the sequence would be _\\\\_EEEE_[[[[_0000_;;;;_3333_;;;;_4444_;;;;_5555_;;;;_7777_;;;;_8888_mmmm_^^^^_NNNN. Now look at when different sequences are output. For example, _;;;;_3333 is output when either _pppp_2222 or _pppp_6666 is true, that is, if either _u_n_d_e_r_l_i_n_e or _b_o_l_d modes are turned on. Writing out the above sequences, along with their dependencies, gives the following: sequence when to output terminfo translation _\\\\_EEEE_[[[[_0000 always _\\\\_EEEE_[[[[_0000 _;;;;_3333 if _pppp_2222 or _pppp_6666 _%%%%_????_%%%%_pppp_2222_%%%%_pppp_6666_%%%%_||||_%%%%_tttt_;;;;_3333_%%%%_;;;; _;;;;_4444 if _pppp_1111 or _pppp_3333 or _pppp_6666 _%%%%_????_%%%%_pppp_1111_%%%%_pppp_3333_%%%%_||||_%%%%_pppp_6666_%%%%_||||_%%%%_tttt_;;;;_4444_%%%%_;;;; _;;;;_5555 if _pppp_4444 _%%%%_????_%%%%_pppp_4444_%%%%_tttt_;;;;_5555_%%%%_;;;; _;;;;_7777 if _pppp_1111 or _pppp_5555 _%%%%_????_%%%%_pppp_1111_%%%%_pppp_5555_%%%%_||||_%%%%_tttt_;;;;_7777_%%%%_;;;; _;;;;_8888 if _pppp_7777 _%%%%_????_%%%%_pppp_7777_%%%%_tttt_;;;;_8888_%%%%_;;;; _mmmm always _mmmm _^^^^_NNNN or _^^^^_OOOO if _pppp_9999 _^^^^_NNNN, else _^^^^_OOOO _%%%%_????_%%%%_pppp_9999_%%%%_tttt_^^^^_NNNN_%%%%_eeee_^^^^_OOOO_%%%%_;;;; PPPPaaaaggggeeee 22223333 NNNN NNNN Putting this all together into the _ssss_gggg_rrrr sequence gives: _ssss_gggg_rrrr_====_\\\\_EEEE_[[[[_0000_%%%%_????_%%%%_pppp_2222_%%%%_pppp_6666_%%%%_||||_%%%%_tttt_;;;;_3333_%%%%_;;;;_%%%%_????_%%%%_pppp_1111_%%%%_pppp_3333_%%%%_||||_%%%%_pppp_6666_%%%% _||||_%%%%_tttt_;;;;_4444_%%%%_;;;;_%%%%_????_%%%%_pppp_5555_%%%%_tttt_;;;;_5555_%%%%_;;;;_%%%%_????_%%%%_pppp_1111_%%%%_pppp_5555_%%%% _||||_%%%%_tttt_;;;;_7777_%%%%_;;;;_%%%%_????_%%%%_pppp_7777_%%%%_tttt_;;;;_8888_%%%%_;;;;_mmmm_%%%%_????_%%%%_pppp_9999_%%%%_tttt_^^^^_NNNN_%%%%_eeee_^^^^_OOOO_%%%%_;;;;_,,,, Remember that _ssss_gggg_rrrr and _ssss_gggg_rrrr_0000 must always be specified. SSSSeeeeccccttttiiiioooonnnn 1111----8888:::: KKKKeeeeyyyyppppaaaadddd If the device has a keypad that transmits sequences when the keys are pressed, this information can also be specified. Note that it is not possible to handle devices where the keypad only works in local (this applies, for example, to the unshifted Hewlett-Packard 2621 keys). If the keypad can be set to transmit or not transmit, specify these sequences as _ssss_mmmm_kkkk_xxxx and _rrrr_mmmm_kkkk_xxxx. Otherwise the keypad is assumed to always transmit. The sequences sent by the left arrow, right arrow, up arrow, down arrow, and home keys can be given as _kkkk_cccc_uuuu_bbbb_1111_,,,, _kkkk_cccc_uuuu_ffff_1111_,,,, _kkkk_cccc_uuuu_uuuu_1111_,,,, _kkkk_cccc_uuuu_dddd_1111_,,,, and _kkkk_hhhh_oooo_mmmm_eeee, respectively. If there are function keys such as f0, f1, ..., f63, the sequences they send can be specified as _kkkk_ffff_0000_,,,, _kkkk_ffff_1111_,,,, _...._...._...._,,,, _kkkk_ffff_6666_3333. If the first 11 keys have labels other than the default f0 through f10, the labels can be given as _llll_ffff_0000_,,,, _llll_ffff_1111_,,,, _...._...._...._,,,, _llll_ffff_1111_0000. The codes transmitted by certain other special keys can be given: _kkkk_llll_llll (home down), _kkkk_bbbb_ssss (backspace), _kkkk_tttt_bbbb_cccc (clear all tabs), _kkkk_cccc_tttt_aaaa_bbbb (clear the tab stop in this column), _kkkk_cccc_llll_rrrr (clear screen or erase key), _kkkk_dddd_cccc_hhhh_1111 (delete character), _kkkk_dddd_llll_1111 (delete line), _kkkk_rrrr_mmmm_iiii_rrrr (exit insert mode), _kkkk_eeee_llll (clear to end of line), _kkkk_eeee_dddd (clear to end of screen), _kkkk_iiii_cccc_hhhh_1111 (insert character or enter insert mode), _kkkk_iiii_llll_1111 (insert line), _kkkk_nnnn_pppp (next page), _kkkk_pppp_pppp (previous page), _kkkk_iiii_nnnn_dddd (scroll forward/down), _kkkk_rrrr_iiii (scroll backward/up), _kkkk_hhhh_tttt_ssss (set a tab stop in this column). In addition, if the keypad has a 3 by 3 array of keys including the four arrow keys, the other five keys can be given as _kkkk_aaaa_1111, _kkkk_aaaa_3333, _kkkk_bbbb_2222, _kkkk_cccc_1111, and _kkkk_cccc_3333. These keys are useful when the effects of a 3 by 3 directional pad are needed. Further keys are defined above in the capabilities list. Strings to program function keys can be specified as _pppp_ffff_kkkk_eeee_yyyy, _pppp_ffff_llll_oooo_cccc, and _pppp_ffff_xxxx. A string to program screen labels should be specified as _pppp_llll_nnnn. Each of these strings takes two parameters: a function key identifier and a string to program it with. _pppp_ffff_kkkk_eeee_yyyy causes pressing the given key to be the same as the user typing the given string; _pppp_ffff_llll_oooo_cccc causes the string to be executed by the terminal in local mode; and _pppp_ffff_xxxx causes the string to be transmitted to the computer. The capabilities _nnnn_llll_aaaa_bbbb, _llll_wwww and _llll_hhhh define the number of programmable screen labels and their width and height. If there are commands to turn the labels on and off, give them in _ssss_mmmm_llll_nnnn and _rrrr_mmmm_llll_nnnn. _ssss_mmmm_llll_nnnn is normally output after one or more _pppp_llll_nnnn sequences to make sure that the change becomes visible. SSSSeeeeccccttttiiiioooonnnn 1111----9999:::: TTTTaaaabbbbssss aaaannnndddd IIIInnnniiiittttiiiiaaaalllliiiizzzzaaaattttiiiioooonnnn If the device has hardware tabs, the command to advance to the next tab stop can be given as _hhhh_tttt (usually control I). A ``backtab'' command that moves leftward to the next tab stop can be given as _cccc_bbbb_tttt. By convention, PPPPaaaaggggeeee 22224444 NNNN NNNN if tty modes show that tabs are being expanded by the computer rather than being sent to the device, programs should not use _hhhh_tttt or _cccc_bbbb_tttt (even if they are present) because the user may not have the tab stops properly set. If the device has hardware tabs that are initially set every _n spaces when the device is powered up, the numeric parameter _iiii_tttt is given, showing the number of spaces the tabs are set to. This is normally used by _tttt_pppp_uuuu_tttt _iiii_nnnn_iiii_tttt [see _tttt_pppp_uuuu_tttt(1)] to determine whether to set the mode for hardware tab expansion and whether to set the tab stops. If the device has tab stops that can be saved in nonvolatile memory, the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo description can assume that they are properly set. If there are commands to set and clear tab stops, they can be given as _tttt_bbbb_cccc (clear all tab stops) and _hhhh_tttt_ssss (set a tab stop in the current column of every row). Other capabilities include: _iiii_ssss_1111, _iiii_ssss_2222, and _iiii_ssss_3333, initialization strings for the device; _iiii_pppp_rrrr_oooo_gggg, the path name of a program to be run to initialize the device; and _iiii_ffff, the name of a file containing long initialization strings. These strings are expected to set the device into modes consistent with the rest of the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo description. They must be sent to the device each time the user logs in and be output in the following order: run the program _iiii_pppp_rrrr_oooo_gggg; output _iiii_ssss_1111; output _iiii_ssss_2222; set the margins using _mmmm_gggg_cccc, _ssss_mmmm_gggg_llll and _ssss_mmmm_gggg_rrrr; set the tabs using _tttt_bbbb_cccc and _hhhh_tttt_ssss; print the file _iiii_ffff; and finally output _iiii_ssss_3333. This is usually done using the _iiii_nnnn_iiii_tttt option of _tttt_pppp_uuuu_tttt. Most initialization is done with _iiii_ssss_2222. Special device modes can be set up without duplicating strings by putting the common sequences in _iiii_ssss_2222 and special cases in _iiii_ssss_1111 and _iiii_ssss_3333. Sequences that do a reset from a totally unknown state can be given as _rrrr_ssss_1111, _rrrr_ssss_2222, _rrrr_ffff, and _rrrr_ssss_3333, analogous to _iiii_ssss_1111, _iiii_ssss_2222, _iiii_ssss_3333, and _iiii_ffff. (The method using files, _iiii_ffff and _rrrr_ffff, is used for a few terminals, from _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_aaaa_bbbb_ssss_eeee_tttt_////_****; however, the recommended method is to use the initialization and reset strings.) These strings are output by _tttt_pppp_uuuu_tttt reset, which is used when the terminal gets into a wedged state. Commands are normally placed in _rrrr_ssss_1111, _rrrr_ssss_2222, _rrrr_ssss_3333, and _rrrr_ffff only if they produce annoying effects on the screen and are not necessary when logging in. For example, the command to set a terminal into 80-column mode would normally be part of _iiii_ssss_2222, but on some terminals it causes an annoying glitch on the screen and is not normally needed because the terminal is usually already in 80-column mode. If a more complex sequence is needed to set the tabs than can be described by using _tttt_bbbb_cccc and _hhhh_tttt_ssss, the sequence can be placed in _iiii_ssss_2222 or _iiii_ffff. Any margin can be cleared with _mmmm_gggg_cccc. (For instructions on how to specify commands to set and clear margins, see "Margins" below under "PRINTER CAPABILITIES.") SSSSeeeeccccttttiiiioooonnnn 1111----11110000:::: DDDDeeeellllaaaayyyyssss Certain capabilities control padding in the _tttt_tttt_yyyy driver. These are primarily needed by hard-copy terminals, and are used by _tttt_pppp_uuuu_tttt _iiii_nnnn_iiii_tttt to set tty modes appropriately. Delays embedded in the capabilities _cccc_rrrr, _iiii_nnnn_dddd, _cccc_uuuu_bbbb_1111, _ffff_ffff, and _tttt_aaaa_bbbb can be used to set the appropriate delay bits to be set in the tty driver. If _pppp_bbbb (padding baud rate) is given, these values can PPPPaaaaggggeeee 22225555 NNNN NNNN be ignored at baud rates below the value of _pppp_bbbb. SSSSeeeeccccttttiiiioooonnnn 1111----11111111:::: SSSSttttaaaattttuuuussss LLLLiiiinnnneeeessss If the terminal has an extra ``status line'' that is not normally used by software, this fact can be indicated. If the status line is viewed as an extra line below the bottom line, into which one can cursor address normally (such as the Heathkit h19's 25th line, or the 24th line of a VT100 which is set to a 23-line scrolling region), the capability _hhhh_ssss should be given. Special strings that go to a given column of the status line and return from the status line can be given as _tttt_ssss_llll and _ffff_ssss_llll. (_ffff_ssss_llll must leave the cursor position in the same place it was before _tttt_ssss_llll. If necessary, the _ssss_cccc and _rrrr_cccc strings can be included in _tttt_ssss_llll and _ffff_ssss_llll to get this effect.) The capability _tttt_ssss_llll takes one parameter, which is the column number of the status line the cursor is to be moved to. If escape sequences and other special commands, such as tab, work while in the status line, the flag _eeee_ssss_llll_oooo_kkkk can be given. A string which turns off the status line (or otherwise erases its contents) should be given as _dddd_ssss_llll. If the terminal has commands to save and restore the position of the cursor, give them as _ssss_cccc and _rrrr_cccc. The status line is normally assumed to be the same width as the rest of the screen, for example, _cccc_oooo_llll_ssss. If the status line is a different width (possibly because the terminal does not allow an entire line to be loaded) the width, in columns, can be indicated with the numeric parameter _wwww_ssss_llll. SSSSeeeeccccttttiiiioooonnnn 1111----11112222:::: LLLLiiiinnnneeee GGGGrrrraaaapppphhhhiiiiccccssss If the device has a line drawing alternate character set, the mapping of glyph to character would be given in _aaaa_cccc_ssss_cccc. The definition of this string is based on the alternate character set used in the DEC VT100 terminal, extended slightly with some characters from the AT&T 4410v1 terminal. vt100+ glyph name character arrow pointing right _++++ arrow pointing left _,,,, arrow pointing down _.... solid square block _0000 lantern symbol _IIII arrow pointing up _---- diamond _```` checker board (stipple) _aaaa degree symbol _ffff plus/minus _gggg board of squares _hhhh lower right corner _jjjj upper right corner _kkkk upper left corner _llll lower left corner _mmmm plus _nnnn scan line 1 _oooo PPPPaaaaggggeeee 22226666 NNNN NNNN horizontal line _qqqq scan line 9 _ssss left tee (|-) _tttt right tee (-|) _uuuu bottom tee (_|) _vvvv top tee (_|) _wwww vertical line _xxxx bullet _~~~~ The best way to describe a new device's line graphics set is to add a third column to the above table with the characters for the new device that produce the appropriate glyph when the device is in the alternate character set mode. For example, vt100+ new tty glyph name char char upper left corner _llll _RRRR lower left corner _mmmm _FFFF upper right corner _kkkk _TTTT lower right corner _jjjj _GGGG horizontal line _qqqq _,,,, vertical line _xxxx _.... Now write down the characters left to right, as in ``_aaaa_cccc_ssss_cccc_====_llll_RRRR_mmmm_FFFF_kkkk_TTTT_jjjj_GGGG_qqqq_\\\\_,,,,_xxxx_....''. In addition, _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo allows you to define multiple character sets. See Section 2-5 for details. SSSSeeeeccccttttiiiioooonnnn 1111----11113333:::: CCCCoooolllloooorrrr MMMMaaaannnniiiippppuuuullllaaaattttiiiioooonnnn Let us define two methods of color manipulation: the Tektronix method and the HP method. The Tektronix method uses a set of N predefined colors (usually 8) from which a user can select "current" foreground and background colors. Thus a terminal can support up to N colors mixed into N*N color-pairs to be displayed on the screen at the same time. When using an HP method the user cannot define the foreground independently of the background, or vice-versa. Instead, the user must define an entire color-pair at once. Up to M color-pairs, made from 2*M different colors, can be defined this way. Most existing color terminals belong to one of these two classes of terminals. The numeric variables _cccc_oooo_llll_oooo_rrrr_ssss and _pppp_aaaa_iiii_rrrr_ssss define the number of colors and color-pairs that can be displayed on the screen at the same time. If a terminal can change the definition of a color (for example, the Tektronix 4100 and 4200 series terminals), this should be specified with _cccc_cccc_cccc (can change color). To change the definition of a color (Tektronix 4200 method), use _iiii_nnnn_iiii_tttt_cccc (initialize color). It requires four arguments: color number (ranging from 0 to _cccc_oooo_llll_oooo_rrrr_ssss-1) and three RGB (red, green, and blue) values or three HLS colors (Hue, Lightness, Saturation). Ranges of RGB and HLS values are terminal dependent. PPPPaaaaggggeeee 22227777 NNNN NNNN Tektronix 4100 series terminals only use HLS color notation. For such terminals (or dual-mode terminals to be operated in HLS mode) one must define a boolean variable _hhhh_llll_ssss; that would instruct the _cccc_uuuu_rrrr_ssss_eeee_ssss _iiii_nnnn_iiii_tttt______cccc_oooo_llll_oooo_rrrr routine to convert its RGB arguments to HLS before sending them to the terminal. The last three arguments to the _iiii_nnnn_iiii_tttt_cccc string would then be HLS values. If a terminal can change the definitions of colors, but uses a color notation different from RGB and HLS, a mapping to either RGB or HLS must be developed. To set current foreground or background to a given color, use _ssss_eeee_tttt_aaaa_ffff (set ANSI foreground) and _ssss_eeee_tttt_aaaa_bbbb (set ANSI background). They require one parameter: the number of the color. To initialize a color-pair (HP method), use _iiii_nnnn_iiii_tttt_pppp (initialize pair). It requires seven parameters: the number of a color-pair (range=0 to _pppp_aaaa_iiii_rrrr_ssss-1), and six RGB values: three for the foreground followed by three for the background. (Each of these groups of three should be in the order RGB.) When _iiii_nnnn_iiii_tttt_cccc or _iiii_nnnn_iiii_tttt_pppp are used, RGB or HLS arguments should be in the order "red, green, blue" or "hue, lightness, saturation"), respectively. To make a color-pair current, use _ssss_cccc_pppp (set color-pair). It takes one parameter, the number of a color-pair. Some terminals (for example, most color terminal emulators for PCs) erase areas of the screen with current background color. In such cases, _bbbb_cccc_eeee (background color erase) should be defined. The variable _oooo_pppp (original pair) contains a sequence for setting the foreground and the background colors to what they were at the terminal start-up time. Similarly, _oooo_cccc (original colors) contains a control sequence for setting all colors (for the Tektronix method) or color-pairs (for the HP method) to the values they had at the terminal start-up time. Some color terminals substitute color for video attributes. Such video attributes should not be combined with colors. Information about these video attributes should be packed into the _nnnn_cccc_vvvv (no color video) variable. There is a one-to-one correspondence between the nine least significant bits of that variable and the video attributes. The following table depicts this correspondence. Bit Decimal Attribute Position Value _________________________________ _AAAA______SSSS_TTTT_AAAA_NNNN_DDDD_OOOO_UUUU_TTTT 0 1 _AAAA______UUUU_NNNN_DDDD_EEEE_RRRR_LLLL_IIII_NNNN_EEEE 1 2 _AAAA______RRRR_EEEE_VVVV_EEEE_RRRR_SSSS_EEEE 2 4 _AAAA______BBBB_LLLL_IIII_NNNN_KKKK 3 8 _AAAA______DDDD_IIII_MMMM 4 16 _AAAA______BBBB_OOOO_LLLL_DDDD 5 32 _AAAA______IIII_NNNN_VVVV_IIII_SSSS 6 64 _AAAA______PPPP_RRRR_OOOO_TTTT_EEEE_CCCC_TTTT 7 128 PPPPaaaaggggeeee 22228888 NNNN NNNN _AAAA______AAAA_LLLL_TTTT_CCCC_HHHH_AAAA_RRRR_SSSS_EEEE_TTTT 8 256 When a particular video attribute should not be used with colors, the corresponding _nnnn_cccc_vvvv bit should be set to 1; otherwise it should be set to zero. To determine the information to pack into the _nnnn_cccc_vvvv variable, you must add together the decimal values corresponding to those attributes that cannot coexist with colors. For example, if the terminal uses colors to simulate reverse video (bit number 2 and decimal value 4) and bold (bit number 5 and decimal value 32), the resulting value for _nnnn_cccc_vvvv will be 36 (4 + 32). SSSSeeeeccccttttiiiioooonnnn 1111----11114444:::: MMMMiiiisssscccceeeellllllllaaaannnneeeeoooouuuussss If the terminal requires other than a null (zero) character as a pad, then this can be given as _pppp_aaaa_dddd. Only the first character of the _pppp_aaaa_dddd string is used. If the terminal does not have a pad character, specify _nnnn_pppp_cccc. If the terminal can move up or down half a line, this can be indicated with _hhhh_uuuu (half-line up) and _hhhh_dddd (half-line down). This is primarily useful for superscripts and subscripts on hardcopy terminals. If a hardcopy terminal can eject to the next page (form feed), give this as _ffff_ffff (usually control L). If there is a command to repeat a given character a given number of times (to save time transmitting a large number of identical characters) this can be indicated with the parameterized string _rrrr_eeee_pppp. The first parameter is the character to be repeated and the second is the number of times to repeat it. Thus, _tttt_pppp_aaaa_rrrr_mmmm_((((_rrrr_eeee_pppp_eeee_aaaa_tttt______cccc_hhhh_aaaa_rrrr_,,,, _''''_xxxx_''''_,,,, _1111_0000_)))) is the same as _xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_xxxx_.... If the terminal has a settable command character, such as the Tektronix 4025, this can be indicated with _cccc_mmmm_dddd_cccc_hhhh. A prototype command character is chosen which is used in all capabilities. This character is given in the _cccc_mmmm_dddd_cccc_hhhh capability to identify it. The following convention is supported on some UNIX systems: If the environment variable _CCCC_CCCC exists, all occurrences of the prototype character are replaced with the character in _CCCC_CCCC. Terminal descriptions that do not represent a specific kind of known terminal, such as _s_w_i_t_c_h, _d_i_a_l_u_p, _p_a_t_c_h, and _n_e_t_w_o_r_k, should include the _gggg_nnnn (generic) capability so that programs can complain that they do not know how to talk to the terminal. (This capability does not apply to _v_i_r_t_u_a_l terminal descriptions for which the escape sequences are known.) If the terminal is one of those supported by the UNIX system virtual terminal protocol, the terminal number can be given as _vvvv_tttt. A line-turn- around sequence to be transmitted before doing reads should be specified in _rrrr_ffff_iiii. If the device uses xon/xoff handshaking for flow control, give _xxxx_oooo_nnnn. Padding information should still be included so that routines can make better decisions about costs, but actual pad characters will not be transmitted. Sequences to turn on and off xon/xoff handshaking may be given in _ssss_mmmm_xxxx_oooo_nnnn and _rrrr_mmmm_xxxx_oooo_nnnn. If the characters used for handshaking are not _^^^^_SSSS and _^^^^_QQQQ, they may be specified with _xxxx_oooo_nnnn_cccc and _xxxx_oooo_ffff_ffff_cccc. PPPPaaaaggggeeee 22229999 NNNN NNNN If the terminal has a ``meta key'' which acts as a shift key, setting the 8th bit of any character transmitted, this fact can be indicated with _kkkk_mmmm. Otherwise, software will assume that the 8th bit is parity and it will usually be cleared. If strings exist to turn this ``meta mode'' on and off, they can be given as _ssss_mmmm_mmmm and _rrrr_mmmm_mmmm. If the terminal has more lines of memory than will fit on the screen at once, the number of lines of memory can be indicated with _llll_mmmm. A value of _llll_mmmm#0 indicates that the number of lines is not fixed, but that there is still more memory than fits on the screen. Media copy strings which control an auxiliary printer connected to the terminal can be given as _mmmm_cccc_0000: print the contents of the screen, _mmmm_cccc_4444: turn off the printer, and _mmmm_cccc_5555: turn on the printer. When the printer is on, all text sent to the terminal will be sent to the printer. A variation, _mmmm_cccc_5555_pppp, takes one parameter, and leaves the printer on for as many characters as the value of the parameter, then turns the printer off. The parameter should not exceed 255. If the text is not displayed on the terminal screen when the printer is on, specify _mmmm_cccc_5555_iiii (silent printer). All text, including _mmmm_cccc_4444, is transparently passed to the printer while an _mmmm_cccc_5555_pppp is in effect. SSSSeeeeccccttttiiiioooonnnn 1111----11115555:::: SSSSppppeeeecccciiiiaaaallll CCCCaaaasssseeeessss The working model used by _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo fits most terminals reasonably well. However, some terminals do not completely match that model, requiring special support by _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo. These are not meant to be construed as deficiencies in the terminals; they are just differences between the working model and the actual hardware. They may be unusual devices or, for some reason, do not have all the features of the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo model implemented. Terminals that cannot display tilde (~) characters, such as certain Hazeltine terminals, should indicate _hhhh_zzzz. Terminals that ignore a linefeed immediately after an _aaaa_mmmm wrap, such as the Concept 100, should indicate _xxxx_eeee_nnnn_llll. Those terminals whose cursor remains on the right-most column until another character has been received, rather than wrapping immediately upon receiving the right-most character, such as the VT100, should also indicate _xxxx_eeee_nnnn_llll. If _eeee_llll is required to get rid of standout (instead of writing normal text on top of it), _xxxx_hhhh_pppp should be given. Those Teleray terminals whose tabs turn all characters moved over to blanks, should indicate _xxxx_tttt (destructive tabs). This capability is also taken to mean that it is not possible to position the cursor on top of a ``magic cookie.'' Therefore, to erase standout mode, it is necessary, instead, to use delete and insert line. Those Beehive Superbee terminals which do not transmit the escape or control-C characters, should specify _xxxx_ssss_bbbb, indicating that the f1 key is to be used for escape and the f2 key for control C. PPPPaaaaggggeeee 33330000 NNNN NNNN SSSSeeeeccccttttiiiioooonnnn 1111----11116666:::: SSSSiiiimmmmiiiillllaaaarrrr TTTTeeeerrrrmmmmiiiinnnnaaaallllssss If there are two very similar terminals, one can be defined as being just like the other with certain exceptions. The string capability _uuuu_ssss_eeee can be given with the name of the similar terminal. The capabilities given before _uuuu_ssss_eeee override those in the terminal type invoked by _uuuu_ssss_eeee. A capability can be canceled by placing _x_x_@@@@ to the left of the capability definition, where _x_x is the capability. For example, the entry _aaaa_tttt_tttt_4444_4444_2222_4444_----_2222_||||_TTTT_eeee_llll_eeee_tttt_yyyy_pppp_eeee _4444_4444_2222_4444 _iiii_nnnn _dddd_iiii_ssss_pppp_llll_aaaa_yyyy _ffff_uuuu_nnnn_cccc_tttt_iiii_oooo_nnnn _gggg_rrrr_oooo_uuuu_pppp _iiii_iiii_,,,, _rrrr_eeee_vvvv_@@@@_,,,, _ssss_gggg_rrrr_@@@@_,,,, _ssss_mmmm_uuuu_llll_@@@@_,,,, _uuuu_ssss_eeee_====_aaaa_tttt_tttt_4444_4444_2222_4444_,,,, defines an AT&T 4424 terminal that does not have the _rrrr_eeee_vvvv, _ssss_gggg_rrrr, and _ssss_mmmm_uuuu_llll capabilities, and hence cannot do highlighting. This is useful for different modes for a terminal, or for different user preferences. More than one _uuuu_ssss_eeee capability may be given. PPPPAAAARRRRTTTT 2222:::: PPPPRRRRIIIINNNNTTTTEEEERRRR CCCCAAAAPPPPAAAABBBBIIIILLLLIIIITTTTIIIIEEEESSSS The _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo database allows you to define capabilities of printers as well as terminals. To find out what capabilities are available for printers as well as for terminals, see the two lists under "DEVICE CAPABILITIES" that list capabilities by variable and by capability name. SSSSeeeeccccttttiiiioooonnnn 2222----1111:::: RRRRoooouuuunnnnddddiiiinnnngggg VVVVaaaalllluuuueeeessss Because parameterized string capabilities work only with integer values, we recommend that _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo designers create strings that expect numeric values that have been rounded. Application designers should note this and should always round values to the nearest integer before using them with a parameterized string capability. SSSSeeeeccccttttiiiioooonnnn 2222----2222:::: PPPPrrrriiiinnnntttteeeerrrr RRRReeeessssoooolllluuuuttttiiiioooonnnn A printer's resolution is defined to be the smallest spacing of characters it can achieve. In general printers have independent resolution horizontally and vertically. Thus the vertical resolution of a printer can be determined by measuring the smallest achievable distance between consecutive printing baselines, while the horizontal resolution can be determined by measuring the smallest achievable distance between the left-most edges of consecutive printed, identical, characters. All printers are assumed to be capable of printing with a uniform horizontal and vertical resolution. The view of printing that _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo currently presents is one of printing inside a uniform matrix: All characters are printed at fixed positions relative to each ``cell'' in the matrix; furthermore, each cell has the same size given by the smallest horizontal and vertical step sizes dictated by the resolution. (The cell size can be changed as will be seen later.) Many printers are capable of ``proportional printing,'' where the horizontal spacing depends on the size of the character last printed. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo does not make use of this capability, although it does provide enough capability definitions to allow an application to simulate proportional printing. PPPPaaaaggggeeee 33331111 NNNN NNNN A printer must not only be able to print characters as close together as the horizontal and vertical resolutions suggest, but also of ``moving'' to a position an integral multiple of the smallest distance away from a previous position. Thus printed characters can be spaced apart a distance that is an integral multiple of the smallest distance, up to the length or width of a single page. Some printers can have different resolutions depending on different ``modes.'' In ``normal mode,'' the existing _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo capabilities are assumed to work on columns and lines, just like a video terminal. Thus the old _llll_iiii_nnnn_eeee_ssss capability would give the length of a page in lines, and the _cccc_oooo_llll_ssss capability would give the width of a page in columns. In ``micro mode,'' many _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo capabilities work on increments of lines and columns. With some printers the micro mode may be concomitant with normal mode, so that all the capabilities work at the same time. SSSSeeeeccccttttiiiioooonnnn 2222----3333:::: SSSSppppeeeecccciiiiffffyyyyiiiinnnngggg PPPPrrrriiiinnnntttteeeerrrr RRRReeeessssoooolllluuuuttttiiiioooonnnn The printing resolution of a printer is given in several ways. Each specifies the resolution as the number of smallest steps per distance: Specification of Printer Resolution Characteristic Number of Smallest Steps __________________________________________ _oooo_rrrr_hhhh_iiii Steps per inch horizontally _oooo_rrrr_vvvv_iiii Steps per inch vertically _oooo_rrrr_cccc Steps per column _oooo_rrrr_llll Steps per line When printing in normal mode, each character printed causes movement to the next column, except in special cases described later; the distance moved is the same as the per-column resolution. Some printers cause an automatic movement to the next line when a character is printed in the rightmost position; the distance moved vertically is the same as the per-line resolution. When printing in micro mode, these distances can be different, and may be zero for some printers. Specification of Printer Resolution Automatic Motion after Printing ________________________________________ _N_o_r_m_a_l _M_o_d_e: _oooo_rrrr_cccc Steps moved horizontally _oooo_rrrr_llll Steps moved vertically _M_i_c_r_o _M_o_d_e: _mmmm_cccc_ssss Steps moved horizontally _mmmm_llll_ssss Steps moved vertically Some printers are capable of printing wide characters. The distance moved when a wide character is printed in normal mode may be different from when a regular width character is printed. The distance moved when a wide character is printed in micro mode may also be different from when a regular character is printed in micro mode, but the differences are assumed to be related: If the distance moved for a regular character is the same whether in normal mode or micro mode (_mmmm_cccc_ssss=_oooo_rrrr_cccc), then the PPPPaaaaggggeeee 33332222 NNNN NNNN distance moved for a wide character is also the same whether in normal mode or micro mode. This doesn't mean the normal character distance is necessarily the same as the wide character distance, just that the distances don't change with a change in normal to micro mode. However, if the distance moved for a regular character is different in micro mode from the distance moved in normal mode (_mmmm_cccc_ssss<_oooo_rrrr_cccc), the micro mode distance is assumed to be the same for a wide character printed in micro mode, as the table below shows. Specification of Printer Resolution Automatic Motion after Printing Wide Character ______________________________________________________ _N_o_r_m_a_l _M_o_d_e _o_r _M_i_c_r_o _M_o_d_e (_mmmm_cccc_ssss = _oooo_rrrr_cccc): _wwww_iiii_dddd_cccc_ssss Steps moved horizontally _M_i_c_r_o _M_o_d_e (_mmmm_cccc_ssss < _oooo_rrrr_cccc): _mmmm_cccc_ssss Steps moved horizontally There may be control sequences to change the number of columns per inch (the character pitch) and to change the number of lines per inch (the line pitch). If these are used, the resolution of the printer changes, but the type of change depends on the printer: Specification of Printer Resolution Changing the Character/Line Pitches ______________________________________________________ _cccc_pppp_iiii Change character pitch _cccc_pppp_iiii_xxxx If set, _cccc_pppp_iiii changes _oooo_rrrr_hhhh_iiii, otherwise changes _oooo_rrrr_cccc _llll_pppp_iiii Change line pitch _llll_pppp_iiii_xxxx If set, _llll_pppp_iiii changes _oooo_rrrr_vvvv_iiii, otherwise changes _oooo_rrrr_llll _cccc_hhhh_rrrr Change steps per column _cccc_vvvv_rrrr Change steps per line The _cccc_pppp_iiii and _llll_pppp_iiii string capabilities are each used with a single argument, the pitch in columns (or characters) and lines per inch, respectively. The _cccc_hhhh_rrrr and _cccc_vvvv_rrrr string capabilities are each used with a single argument, the number of steps per column and line, respectively. Using any of the control sequences in these strings will imply a change in some of the values of _oooo_rrrr_cccc, _oooo_rrrr_hhhh_iiii, _oooo_rrrr_llll, and _oooo_rrrr_vvvv_iiii. Also, the distance moved when a wide character is printed, _wwww_iiii_dddd_cccc_ssss, changes in relation to _oooo_rrrr_cccc. The distance moved when a character is printed in micro mode, _mmmm_cccc_ssss, changes similarly, with one exception: if the distance is 0 or 1, then no change is assumed (see items marked with |- in the following table). Programs that use _cccc_pppp_iiii, _llll_pppp_iiii, _cccc_hhhh_rrrr, or _cccc_vvvv_rrrr should recalculate the printer resolution (and should recalculate other values see "Effect of Changing Printing Resolution" under "Dot-Mapped Graphics"). Specification of Printer Resolution Effects of Changing the Character/Line Pitches PPPPaaaaggggeeee 33333333 NNNN NNNN ________________________________________________ _B_e_f_o_r_e _A_f_t_e_r _______________________________________________ Using _cccc_pppp_iiii with _cccc_pppp_iiii_xxxx clear: orhi' oooorrrrhhhhiiii orc' orc=o_r_h_i_ Vcpi Using _cccc_pppp_iiii with _cccc_pppp_iiii_xxxx set: orhi' orhi=orc.V orc' orc cpi Using _llll_pppp_iiii with _llll_pppp_iiii_xxxx clear: orvi' orvio_r_v_i_ orl' orl=V lpi Using _llll_pppp_iiii with _llll_pppp_iiii_xxxx set: . orvi' orvi=orl Vlpi orl' orl Using _cccc_hhhh_rrrr_:::: orhi' orhi orc' V chr Using _cccc_vvvv_rrrr_:::: orvi' orvi orl' Vcvr Using _cccc_pppp_iiii or _cccc_hhhh_rrrr_:::: widcs' widcs=widcs'_o_r_c_ mcs' mcs=mcs'_o_r_c_orc' orc' V , V , V , and V are the arguments used with _cccc_pppp_iiii, _llll_pppp_iiii, _cccc_hhhh_rrrr, and _ccccc_vvvvp_rrrri, relsppiecticvherly. Thecvprrime marks (') indicate the old values. SSSSeeeeccccttttiiiioooonnnn 2222----4444:::: CCCCaaaappppaaaabbbbiiiilllliiiittttiiiieeeessss tttthhhhaaaatttt CCCCaaaauuuusssseeee MMMMoooovvvveeeemmmmeeeennnntttt In the following descriptions, ``movement'' refers to the motion of the ``current position.'' With video terminals this would be the cursor; with some printers this is the carriage position. Other printers have different equivalents. In general, the current position is where a character would be displayed if printed. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo has string capabilities for control sequences that cause movement a number of full columns or lines. It also has equivalent string capabilities for control sequences that cause movement a number of smallest steps. String Capabilities for Motion __________________________________ _mmmm_cccc_uuuu_bbbb_1111 Move 1 step left _mmmm_cccc_uuuu_ffff_1111 Move 1 step right _mmmm_cccc_uuuu_uuuu_1111 Move 1 step up _mmmm_cccc_uuuu_dddd_1111 Move 1 step down _mmmm_cccc_uuuu_bbbb Move _N steps left PPPPaaaaggggeeee 33334444 NNNN NNNN _mmmm_cccc_uuuu_ffff Move _N steps right _mmmm_cccc_uuuu_uuuu Move _N steps up _mmmm_cccc_uuuu_dddd Move _N steps down _mmmm_hhhh_pppp_aaaa Move _N steps from the left _mmmm_vvvv_pppp_aaaa Move _N steps from the top The latter six strings are each used with a single argument, _N. Sometimes the motion is limited to less than the width or length of a page. Also, some printers don't accept absolute motion to the left of the current position. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo has capabilities for specifying these limits. Limits to Motion __________________________________________________ _mmmm_jjjj_uuuu_mmmm_pppp Limit on use of _mmmm_cccc_uuuu_bbbb_1111, _mmmm_cccc_uuuu_ffff_1111, _mmmm_cccc_uuuu_uuuu_1111, _mmmm_cccc_uuuu_dddd_1111 _mmmm_aaaa_dddd_dddd_rrrr Limit on use of _mmmm_hhhh_pppp_aaaa, _mmmm_vvvv_pppp_aaaa _xxxx_hhhh_pppp_aaaa If set, _hhhh_pppp_aaaa and _mmmm_hhhh_pppp_aaaa can't move left _xxxx_vvvv_pppp_aaaa If set, _vvvv_pppp_aaaa and _mmmm_vvvv_pppp_aaaa can't move up If a printer needs to be in a ``micro mode'' for the motion capabilities described above to work, there are string capabilities defined to contain the control sequence to enter and exit this mode. A boolean is available for those printers where using a carriage return causes an automatic return to normal mode. Entering/Exiting Micro Mode _________________________________ _ssss_mmmm_iiii_cccc_mmmm Enter micro mode _rrrr_mmmm_iiii_cccc_mmmm Exit micro mode _cccc_rrrr_xxxx_mmmm Using _cccc_rrrr exits micro mode The movement made when a character is printed in the rightmost position varies among printers. Some make no movement, some move to the beginning of the next line, others move to the beginning of the same line. _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo has boolean capabilities for describing all three cases. What Happens After Character Printed in Rightmost Position ______________________________________________ _ssss_aaaa_mmmm Automatic move to beginning of same line Some printers can be put in a mode where the normal direction of motion is reversed. This mode can be especially useful when there are no capabilities for leftward or upward motion, because those capabilities can be built from the motion reversal capability and the rightward or downward motion capabilities. It is best to leave it up to an application to build the leftward or upward capabilities, though, and not enter them in the _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo database. This allows several reverse motions to be strung together without intervening wasted steps that leave and reenter reverse mode. PPPPaaaaggggeeee 33335555 NNNN NNNN Entering/Exiting Reverse Modes ___________________________________________ _ssss_llll_mmmm Reverse sense of horizontal motions _rrrr_llll_mmmm Restore sense of horizontal motions _ssss_uuuu_mmmm Reverse sense of vertical motions _rrrr_uuuu_mmmm Restore sense of vertical motions _W_h_i_l_e _s_e_n_s_e _o_f _h_o_r_i_z_o_n_t_a_l _m_o_t_i_o_n_s _r_e_v_e_r_s_e_d: _mmmm_cccc_uuuu_bbbb_1111 Move 1 step right _mmmm_cccc_uuuu_ffff_1111 Move 1 step left _mmmm_cccc_uuuu_bbbb Move _N steps right _mmmm_cccc_uuuu_ffff Move _N steps left _cccc_uuuu_bbbb_1111 Move 1 column right _cccc_uuuu_ffff_1111 Move 1 column left _cccc_uuuu_bbbb Move _N columns right _cccc_uuuu_ffff Move _N columns left _W_h_i_l_e _s_e_n_s_e _o_f _v_e_r_t_i_c_a_l _m_o_t_i_o_n_s _r_e_v_e_r_s_e_d: _mmmm_cccc_uuuu_uuuu_1111 Move 1 step down _mmmm_cccc_uuuu_dddd_1111 Move 1 step up _mmmm_cccc_uuuu_uuuu Move _N steps down _mmmm_cccc_uuuu_dddd Move _N steps up _cccc_uuuu_uuuu_1111 Move 1 line down _cccc_uuuu_dddd_1111 Move 1 line up _cccc_uuuu_uuuu Move _N lines down _cccc_uuuu_dddd Move _N lines up The reverse motion modes should not affect the _mmmm_vvvv_pppp_aaaa and _mmmm_hhhh_pppp_aaaa absolute motion capabilities. The reverse vertical motion mode should, however, also reverse the action of the line ``wrapping'' that occurs when a character is printed in the right-most position. Thus printers that have the standard _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo capability _aaaa_mmmm defined should experience motion to the beginning of the previous line when a character is printed in the right-most position under reverse vertical motion mode. The action when any other motion capabilities are used in reverse motion modes is not defined; thus, programs must exit reverse motion modes before using other motion capabilities. Two miscellaneous capabilities complete the list of new motion capabilities. One of these is needed for printers that move the current position to the beginning of a line when certain control characters, such as ``line-feed'' or ``form-feed,'' are used. The other is used for the capability of suspending the motion that normally occurs after printing a character. Miscellaneous Motion Strings ________________________________________________________________ _dddd_oooo_cccc_rrrr List of control characters causing _cccc_rrrr _zzzz_eeee_rrrr_oooo_mmmm Prevent auto motion after printing next single character PPPPaaaaggggeeee 33336666 NNNN NNNN MMMMaaaarrrrggggiiiinnnnssss _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo provides two strings for setting margins on terminals: one for the left and one for the right margin. Printers, however, have two additional margins, for the top and bottom margins of each page. Furthermore, some printers require not using motion strings to move the current position to a margin and then fixing the margin there, but require the specification of where a margin should be regardless of the current position. Therefore _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo offers six additional strings for defining margins with printers. Setting Margins __________________________________________ _ssss_mmmm_gggg_llll Set left margin at current column _ssss_mmmm_gggg_rrrr Set right margin at current column _ssss_mmmm_gggg_bbbb Set bottom margin at current line _ssss_mmmm_gggg_tttt Set top margin at current line _ssss_mmmm_gggg_bbbb_pppp Set bottom margin at line _N _ssss_mmmm_gggg_llll_pppp Set left margin at column _N _ssss_mmmm_gggg_rrrr_pppp Set right margin at column _N _ssss_mmmm_gggg_tttt_pppp Set top margin at line _N The last four strings are used with one or more arguments that give the position of the margin or margins to set. If both of _ssss_mmmm_gggg_llll_pppp and _ssss_mmmm_gggg_rrrr_pppp are set, each is used with a single argument, _N, that gives the column number of the left and right margin, respectively. If both of _ssss_mmmm_gggg_tttt_pppp and _ssss_mmmm_gggg_bbbb_pppp are set, each is used to set the top and bottom margin, respectively: _ssss_mmmm_gggg_tttt_pppp is used with a single argument, _N, the line number of the top margin; however, _ssss_mmmm_gggg_bbbb_pppp is used with two arguments, _N and _M, that give the line number of the bottom margin, the first counting from the top of the page and the second counting from the bottom. This accommodates the two styles of specifying the bottom margin in different manufacturers' printers. When coding a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo entry for a printer that has a settable bottom margin, only the first or second parameter should be used, depending on the printer. When writing an application that uses _ssss_mmmm_gggg_bbbb_pppp to set the bottom margin, both arguments must be given. If only one of _ssss_mmmm_gggg_llll_pppp and _ssss_mmmm_gggg_rrrr_pppp is set, then it is used with two arguments, the column number of the left and right margins, in that order. Likewise, if only one of _ssss_mmmm_gggg_tttt_pppp and _ssss_mmmm_gggg_bbbb_pppp is set, then it is used with two arguments that give the top and bottom margins, in that order, counting from the top of the page. Thus when coding a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo entry for a printer that requires setting both left and right or top and bottom margins simultaneously, only one of _ssss_mmmm_gggg_llll_pppp and _ssss_mmmm_gggg_rrrr_pppp or _ssss_mmmm_gggg_tttt_pppp and _ssss_mmmm_gggg_bbbb_pppp should be defined; the other should be left blank. When writing an application that uses these string capabilities, the pairs should be first checked to see if each in the pair is set or only one is set, and should then be used accordingly. In counting lines or columns, line zero is the top line and column zero is the left-most column. A zero value for the second argument with _ssss_mmmm_gggg_bbbb_pppp means the bottom line of the page. PPPPaaaaggggeeee 33337777 NNNN NNNN All margins can be cleared with _mmmm_gggg_cccc. SSSShhhhaaaaddddoooowwwwssss,,,, IIIIttttaaaalllliiiiccccssss,,,, WWWWiiiiddddeeee CCCChhhhaaaarrrraaaacccctttteeeerrrrssss,,,, SSSSuuuuppppeeeerrrrssssccccrrrriiiippppttttssss,,,, SSSSuuuubbbbssssccccrrrriiiippppttttssss Five new sets of strings are used to describe the capabilities printers have of enhancing printed text. Enhanced Printing ____________________________________________________ _ssss_ssss_hhhh_mmmm Enter shadow-printing mode _rrrr_ssss_hhhh_mmmm Exit shadow-printing mode _ssss_iiii_tttt_mmmm Enter italicizing mode _rrrr_iiii_tttt_mmmm Exit italicizing mode _ssss_wwww_iiii_dddd_mmmm Enter wide character mode _rrrr_wwww_iiii_dddd_mmmm Exit wide character mode _ssss_ssss_uuuu_pppp_mmmm Enter superscript mode _rrrr_ssss_uuuu_pppp_mmmm Exit superscript mode _ssss_uuuu_pppp_cccc_ssss List of characters available as superscripts _ssss_ssss_uuuu_bbbb_mmmm Enter subscript mode _rrrr_ssss_uuuu_bbbb_mmmm Exit subscript mode _ssss_uuuu_bbbb_cccc_ssss List of characters available as subscripts If a printer requires the _ssss_ssss_hhhh_mmmm control sequence before every character to be shadow-printed, the _rrrr_ssss_hhhh_mmmm string is left blank. Thus programs that find a control sequence in _ssss_ssss_hhhh_mmmm but none in _rrrr_ssss_hhhh_mmmm should use the _ssss_ssss_hhhh_mmmm control sequence before every character to be shadow-printed; otherwise, the _ssss_ssss_hhhh_mmmm control sequence should be used once before the set of characters to be shadow-printed, followed by _rrrr_ssss_hhhh_mmmm. The same is also true of each of the _ssss_iiii_tttt_mmmm/_rrrr_iiii_tttt_mmmm, _ssss_wwww_iiii_dddd_mmmm/_rrrr_wwww_iiii_dddd_mmmm, _ssss_ssss_uuuu_pppp_mmmm/_rrrr_ssss_uuuu_pppp_mmmm, and _ssss_ssss_uuuu_bbbb_mmmm/ _rrrr_ssss_uuuu_bbbb_mmmm pairs. Note that _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo also has a capability for printing emboldened text (_bbbb_oooo_llll_dddd). While shadow printing and emboldened printing are similar in that they ``darken'' the text, many printers produce these two types of print in slightly different ways. Generally, emboldened printing is done by overstriking the same character one or more times. Shadow printing likewise usually involves overstriking, but with a slight movement up and/or to the side so that the character is ``fatter.'' It is assumed that enhanced printing modes are independent modes, so that it would be possible, for instance, to shadow print italicized subscripts. As mentioned earlier, the amount of motion automatically made after printing a wide character should be given in _wwww_iiii_dddd_cccc_ssss. If only a subset of the printable ASCII characters can be printed as superscripts or subscripts, they should be listed in _ssss_uuuu_pppp_cccc_ssss or _ssss_uuuu_bbbb_cccc_ssss strings, respectively. If the _ssss_ssss_uuuu_pppp_mmmm or _ssss_ssss_uuuu_bbbb_mmmm strings contain control sequences, but the corresponding _ssss_uuuu_pppp_cccc_ssss or _ssss_uuuu_bbbb_cccc_ssss strings are empty, it is assumed that all printable ASCII characters are available as superscripts PPPPaaaaggggeeee 33338888 NNNN NNNN or subscripts. Automatic motion made after printing a superscript or subscript is assumed to be the same as for regular characters. Thus, for example, printing any of the following three examples will result in equivalent motion: _BBBB_iiii _BBBB _BBBB_iiii _iiii Note that the existing _mmmm_ssss_gggg_rrrr boolean capability describes whether motion control sequences can be used while in ``standout mode.'' This capability is extended to cover the enhanced printing modes added here. _mmmm_ssss_gggg_rrrr should be set for those printers that accept any motion control sequences without affecting shadow, italicized, widened, superscript, or subscript printing. Conversely, if _mmmm_ssss_gggg_rrrr is not set, a program should end these modes before attempting any motion. SSSSeeeeccccttttiiiioooonnnn 2222----5555:::: AAAAlllltttteeeerrrrnnnnaaaatttteeee CCCChhhhaaaarrrraaaacccctttteeeerrrr SSSSeeeettttssss In addition to allowing you to define line graphics (described in Section 1-12), _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo lets you define alternate character sets. The following capabilities cover printers and terminals with multiple selectable or definable character sets. Alternate Character Sets _________________________________________________________ _ssss_cccc_ssss Select character set _N _ssss_cccc_ssss_dddd Start definition of character set _N, _M characters _dddd_eeee_ffff_cccc Define character _A, _B dots wide, descender _D _rrrr_cccc_ssss_dddd End definition of character set _N _cccc_ssss_nnnn_mmmm List of character set names _dddd_aaaa_iiii_ssss_yyyy Printer has manually changed print-wheels The _ssss_cccc_ssss, _rrrr_cccc_ssss_dddd, and _cccc_ssss_nnnn_mmmm strings are used with a single argument, _N, a number from 0 to 63 that identifies the character set. The _ssss_cccc_ssss_dddd string is also used with the argument _N and another, _M, that gives the number of characters in the set. The _dddd_eeee_ffff_cccc string is used with three arguments: _A gives the ASCII code representation for the character, _B gives the width of the character in dots, and _D is zero or one depending on whether the character is a ``descender'' or not. The _dddd_eeee_ffff_cccc string is also followed by a string of ``image-data'' bytes that describe how the character looks (see below). Character set 0 is the default character set present after the printer has been initialized. Not every printer has 64 character sets, of course; using _ssss_cccc_ssss with an argument that doesn't select an available character set should cause a null result from _tttt_pppp_aaaa_rrrr_mmmm. If a character set has to be defined before it can be used, the _ssss_cccc_ssss_dddd control sequence is to be used before defining the character set, and the _rrrr_cccc_ssss_dddd is to be used after. They should also cause a null result from _tttt_pppp_aaaa_rrrr_mmmm when used with an argument _N that doesn't apply. If a character PPPPaaaaggggeeee 33339999 NNNN NNNN set still has to be selected after being defined, the _ssss_cccc_ssss control sequence should follow the _rrrr_cccc_ssss_dddd control sequence. By examining the results of using each of the _ssss_cccc_ssss, _ssss_cccc_ssss_dddd, and _rrrr_cccc_ssss_dddd strings with a character set number in a call to _tttt_pppp_aaaa_rrrr_mmmm, a program can determine which of the three are needed. Between use of the _ssss_cccc_ssss_dddd and _rrrr_cccc_ssss_dddd strings, the _dddd_eeee_ffff_cccc string should be used to define each character. To print any character on printers covered by _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo, the ASCII code is sent to the printer. This is true for characters in an alternate set as well as ``normal'' characters. Thus the definition of a character includes the ASCII code that represents it. In addition, the width of the character in dots is given, along with an indication of whether the character should descend below the print line (such as the lower case letter ``g'' in most character sets). The width of the character in dots also indicates the number of image-data bytes that will follow the _dddd_eeee_ffff_cccc string. These image-data bytes indicate where in a dot-matrix pattern ink should be applied to ``draw'' the character; the number of these bytes and their form are defined below under ``Dot- Mapped Graphics.'' It's easiest for the creator of _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo entries to refer to each character set by number; however, these numbers will be meaningless to the application developer. The _cccc_ssss_nnnn_mmmm string alleviates this problem by providing names for each number. When used with a character set number in a call to _tttt_pppp_aaaa_rrrr_mmmm, the _cccc_ssss_nnnn_mmmm string will produce the equivalent name. These names should be used as a reference only. No naming convention is implied, although anyone who creates a _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo entry for a printer should use names consistent with the names found in user documents for the printer. Application developers should allow a user to specify a character set by number (leaving it up to the user to examine the _cccc_ssss_nnnn_mmmm string to determine the correct number), or by name, where the application examines the _cccc_ssss_nnnn_mmmm string to determine the corresponding character set number. These capabilities are likely to be used only with dot-matrix printers. If they are not available, the strings should not be defined. For printers that have manually changed print-wheels or font cartridges, the boolean _dddd_aaaa_iiii_ssss_yyyy is set. SSSSeeeeccccttttiiiioooonnnn 2222----6666:::: DDDDooootttt----MMMMaaaattttrrrriiiixxxx GGGGrrrraaaapppphhhhiiiiccccssss Dot-matrix printers typically have the capability of reproducing ``raster-graphics'' images. Three new numeric capabilities and three new string capabilities can help a program draw raster-graphics images independent of the type of dot-matrix printer or the number of pins or dots the printer can handle at one time. Dot-Matrix Graphics _______________________________________________________ _nnnn_pppp_iiii_nnnn_ssss Number of pins, _N, in print-head PPPPaaaaggggeeee 44440000 NNNN NNNN _ssss_pppp_iiii_nnnn_vvvv Spacing of pins vertically in pins per inch _ssss_pppp_iiii_nnnn_hhhh Spacing of dots horizontally in dots per inch _pppp_oooo_rrrr_dddd_eeee_rrrr Matches software bits to print-head pins _ssss_bbbb_iiii_mmmm Start printing bit image graphics, _B bits wide _rrrr_bbbb_iiii_mmmm End printing bit image graphics The _ssss_bbbb_iiii_mmmm sring is used with a single argument, _B, the width of the image in dots. The model of dot-matrix or raster-graphics that _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo presents is similar to the technique used for most dot-matrix printers: each pass of the printer's print-head is assumed to produce a dot-matrix that is _N dots high and _B dots wide. This is typically a wide, squat, rectangle of dots. The height of this rectangle in dots will vary from one printer to the next; this is given in the _nnnn_pppp_iiii_nnnn_ssss numeric capability. The size of the rectangle in fractions of an inch will also vary; it can be deduced from the _ssss_pppp_iiii_nnnn_vvvv and _ssss_pppp_iiii_nnnn_hhhh numeric capabilities. With these three values an application can divide a complete raster-graphics image into several horizontal strips, perhaps interpolating to account for different dot spacing vertically and horizontally. The _ssss_bbbb_iiii_mmmm and _rrrr_bbbb_iiii_mmmm strings are used to start and end a dot-matrix image, respectively. The _ssss_bbbb_iiii_mmmm string is used with a single argument that gives the width of the dot-matrix in dots. A sequence of ``image-data bytes'' are sent to the printer after the _ssss_bbbb_iiii_mmmm string and before the _rrrr_bbbb_iiii_mmmm string. The number of bytes is a integral multiple of the width of the dot- matrix; the multiple and the form of each byte is determined by the _pppp_oooo_rrrr_dddd_eeee_rrrr string as described below. The _pppp_oooo_rrrr_dddd_eeee_rrrr string is a comma separated list of pin numbers optionally followed by an numerical offset. The offset, if given, is separated from the list with a semicolon. The position of each pin number in the list corresponds to a bit in an 8-bit data byte. The pins are numbered consecutively from 1 to _nnnn_pppp_iiii_nnnn_ssss, with 1 being the top pin. Note that the term ``pin'' is used loosely here; ``ink-jet'' dot-matrix printers don't have pins, but can be considered to have an equivalent method of applying a single dot of ink to paper. The bit positions in _pppp_oooo_rrrr_dddd_eeee_rrrr are in groups of 8, with the first position in each group the most significant bit and the last position the least significant bit. An application produces 8- bit bytes in the order of the groups in _pppp_oooo_rrrr_dddd_eeee_rrrr. An application computes the ``image-data bytes'' from the internal image, mapping vertical dot positions in each print-head pass into 8-bit bytes, using a 1 bit where ink should be applied and 0 where no ink should be applied. This can be reversed (0 bit for ink, 1 bit for no ink) by giving a negative pin number. If a position is skipped in _pppp_oooo_rrrr_dddd_eeee_rrrr, a 0 bit is used. If a position has a lower case `x' instead of a pin number, a 1 bit is used in the skipped position. For consistency, a lower case `o' can be used to represent a 0 filled, skipped bit. There must be a multiple of 8 bit positions used or skipped in _pppp_oooo_rrrr_dddd_eeee_rrrr; if not, 0 bits are used to fill the last byte in the least significant bits. The offset, if given, is added to each data byte; the offset can be negative. PPPPaaaaggggeeee 44441111 NNNN NNNN Some examples may help clarify the use of the _pppp_oooo_rrrr_dddd_eeee_rrrr string. The AT&T 470, AT&T 475 and C.Itoh 8510 printers provide eight pins for graphics. The pins are identified top to bottom by the 8 bits in a byte, from least significant to most. The _pppp_oooo_rrrr_dddd_eeee_rrrr strings for these printers would be _8888_,,,,_7777_,,,,_6666_,,,,_5555_,,,,_4444_,,,,_3333_,,,,_2222_,,,,_1111. The AT&T 478 and AT&T 479 printers also provide eight pins for graphics. However, the pins are identified in the reverse order. The _pppp_oooo_rrrr_dddd_eeee_rrrr strings for these printers would be _1111_,,,,_2222_,,,,_3333_,,,,_4444_,,,,_5555_,,,,_6666_,,,,_7777_,,,,_8888. The AT&T 5310, AT&T 5320, DEC LA100, and DEC LN03 printers provide six pins for graphics. The pins are identified top to bottom by the decimal values 1, 2, 4, 8, 16 and 32. These correspond to the low six bits in an 8-bit byte, although the decimal values are further offset by the value 63. The _pppp_oooo_rrrr_dddd_eeee_rrrr string for these printers would be _,,,,_,,,,_6666_,,,,_5555_,,,,_4444_,,,,_3333_,,,,_2222_,,,,_1111_;;;;_6666_3333, or alternately _oooo_,,,,_oooo_,,,,_6666_,,,,_5555_,,,,_4444_,,,,_3333_,,,,_2222_,,,,_1111_;;;;_6666_3333. SSSSeeeeccccttttiiiioooonnnn 2222----7777:::: EEEEffffffffeeeecccctttt ooooffff CCCChhhhaaaannnnggggiiiinnnngggg PPPPrrrriiiinnnnttttiiiinnnngggg RRRReeeessssoooolllluuuuttttiiiioooonnnn If the control sequences to change the character pitch or the line pitch are used, the pin or dot spacing may change: Dot-Matrix Graphics Changing the Character/Line Pitches ______________________________________ _cccc_pppp_iiii Change character pitch _cccc_pppp_iiii_xxxx If set, _cccc_pppp_iiii changes _ssss_pppp_iiii_nnnn_hhhh _llll_pppp_iiii Change line pitch _llll_pppp_iiii_xxxx If set, _llll_pppp_iiii changes _ssss_pppp_iiii_nnnn_vvvv Programs that use _cccc_pppp_iiii or _llll_pppp_iiii should recalculate the dot spacing: Dot-Matrix Graphics Effects of Changing the Character/Line Pitches _________________________________________________ Before _A_f_t_e_r _________________________________________________ PPPPaaaaggggeeee 44442222 Using _cccc_pppp_iiii with _cccc_pppp_iiii_xxxx clear: spinh' spinh Using _cccc_pppp_iiii with _cccc_pppp_iiii_xxxx set: ._o_r_h_i_ spinh' spinh=spinh' orhi' Using _llll_pppp_iiii with _llll_pppp_iiii_xxxx clear: spinv' spinv Using _llll_pppp_iiii with _llll_pppp_iiii_xxxx set: ._o_r_h_i_ spinv' spinv=spinv' orhi' Using _cccc_hhhh_rrrr_:::: spinh' spinh Using _cccc_vvvv_rrrr_:::: spinv' spinv oooorrrrhhhhiiii'''' and oooorrrrhhhhiiii are the values of the horizontal resolution in steps per inch, before using _cccc_pppp_iiii and after using _cccc_pppp_iiii, respectively. Likewise, oooorrrrvvvviiii'''' and oooorrrrvvvviiii are the values of the vertical resolution in steps per inch, before using _llll_pppp_iiii and after using _llll_pppp_iiii, respectively. Thus, the changes in the dots per inch for dot-matrix graphics follow the changes in steps per inch for printer resolution. SSSSeeeeccccttttiiiioooonnnn 2222----8888:::: PPPPrrrriiiinnnntttt QQQQuuuuaaaalllliiiittttyyyy Many dot-matrix printers can alter the dot spacing of printed text to produce near ``letter quality'' printing or ``draft quality'' printing. Usually it is important to be able to choose one or the other because the rate of printing generally falls off as the quality improves. There are three new strings used to describe these capabilities. Print Quality _____________________________________ _ssss_nnnn_llll_qqqq Set near-letter quality print _ssss_nnnn_rrrr_mmmm_qqqq Set normal quality print _ssss_dddd_rrrr_ffff_qqqq Set draft quality print The capabilities are listed in decreasing levels of quality. If a printer doesn't have all three levels, one or two of the strings should be left blank as appropriate. SSSSeeeeccccttttiiiioooonnnn 2222----9999:::: PPPPrrrriiiinnnnttttiiiinnnngggg RRRRaaaatttteeee aaaannnndddd BBBBuuuuffffffffeeeerrrr SSSSiiiizzzzeeee Because there is no standard protocol that can be used to keep a program synchronized with a printer, and because modern printers can buffer data before printing it, a program generally cannot determine at any time what has been printed. Two new numeric capabilities can help a program estimate what has been printed. PPPPaaaaggggeeee 44443333 Print Rate/Buffer Size ___________________________________________________ _cccc_pppp_ssss Nominal print rate in characters per second _bbbb_uuuu_ffff_ssss_zzzz Buffer capacity in characters _cccc_pppp_ssss is the nominal or average rate at which the printer prints characters; if this value is not given, the rate should be estimated at one-tenth the prevailing baud rate. _bbbb_uuuu_ffff_ssss_zzzz is the maximum number of subsequent characters buffered before the guaranteed printing of an earlier character, assuming proper flow control has been used. If this value is not given it is assumed that the printer does not buffer characters, but prints them as they are received. As an example, if a printer has a 1000-character buffer, then sending the letter ``a'' followed by 1000 additional characters is guaranteed to cause the letter ``a'' to print. If the same printer prints at the rate of 100 characters per second, then it should take 10 seconds to print all the characters in the buffer, less if the buffer is not full. By keeping track of the characters sent to a printer, and knowing the print rate and buffer size, a program can synchronize itself with the printer. Note that most printer manufacturers advertise the maximum print rate, not the nominal print rate. A good way to get a value to put in for _cccc_pppp_ssss is to generate a few pages of text, count the number of printable characters, and then see how long it takes to print the text. Applications that use these values should recognize the variability in the print rate. Straight text, in short lines, with no embedded control sequences will probably print at close to the advertised print rate and probably faster than the rate in _cccc_pppp_ssss. Graphics data with a lot of control sequences, or very long lines of text, will print at well below the advertised rate and below the rate in _cccc_pppp_ssss. If the application is using _cccc_pppp_ssss to decide how long it should take a printer to print a block of text, the application should pad the estimate. If the application is using _cccc_pppp_ssss to decide how much text has already been printed, it should shrink the estimate. The application will thus err in favor of the user, who wants, above all, to see all the output in its correct place. FFFFIIIILLLLEEEESSSS _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo_////_????_////_**** compiled terminal description database _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_...._CCCC_OOOO_RRRR_EEEE_tttt_eeee_rrrr_mmmm_////_????_////_**** subset of compiled terminal description database _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_aaaa_bbbb_ssss_eeee_tttt_////_**** tab settings for some terminals, in a format appropriate to be output to the terminal (escape sequences that set margins and tabs) PPPPaaaaggggeeee 44444444 SSSSEEEEEEEE AAAALLLLSSSSOOOO _cccc_uuuu_rrrr_ssss_eeee_ssss(3X), _llll_ssss(1), _pppp_gggg(1), _pppp_rrrr_iiii_nnnn_tttt_ffff(3S), _ssss_tttt_tttt_yyyy(1), _tttt_iiii_cccc(1M), _tttt_pppp_uuuu_tttt(1), _tttt_tttt_yyyy(1), _vvvv_iiii(1) NNNNOOOOTTTTEEEESSSS The most effective way to prepare a terminal description is by imitating the description of a similar terminal in _tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo and to build up a description gradually, using partial descriptions with a screen oriented editor, such as _vvvv_iiii, to check that they are correct. To easily test a new terminal description the environment variable _TTTT_EEEE_RRRR_MMMM_IIII_NNNN_FFFF_OOOO can be set to the pathname of a directory containing the compiled description, and programs will look there rather than in _////_uuuu_ssss_rrrr_////_ssss_hhhh_aaaa_rrrr_eeee_////_llll_iiii_bbbb_////_tttt_eeee_rrrr_mmmm_iiii_nnnn_ffff_oooo. PPPPaaaaggggeeee 44445555 lafe/readline/MANIFEST100644 325 24 1324 6106101043 12622 0ustar dlduserdoc d examples d COPYING f README f STANDALONE f MANIFEST f INSTALL f acconfig.h f config.h.in f configure f configure.in f Makefile.in f ChangeLog f ansi_stdlib.h f chardefs.h f keymaps.h f memalloc.h f posixstat.h f history.h f rlconf.h f rldefs.h f tilde.h f bind.c f complete.c f display.c f emacs_keymap.c f funmap.c f history.c f isearch.c f keymaps.c f parens.c f readline.c f readline.h f rltty.c f search.c f signals.c f tilde.c f vi_keymap.c f vi_mode.c f xmalloc.c f doc/Makefile f doc/rlman.texinfo f doc/rltech.texinfo f doc/rluser.texinfo f doc/hist.texinfo f doc/hstech.texinfo f doc/hsuser.texinfo f doc/readline.3 f examples/Makefile f examples/fileman.c f examples/manexamp.c f examples/Inputrc f lafe/readline/bind.c100644 325 24 106213 6106101043 12614 0ustar dlduser/* bind.c -- key binding and startup file support for the readline library. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #if !defined (NO_SYS_FILE) # include #endif /* !NO_SYS_FILE */ #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" /* Some standard library routines. */ #include "readline.h" #include "history.h" #if !defined (strchr) && !defined (__STDC__) extern char *strchr (), *strrchr (); #endif /* !strchr && !__STDC__ */ extern int _rl_horizontal_scroll_mode; extern int _rl_mark_modified_lines; extern int _rl_bell_preference; extern int _rl_meta_flag; extern int _rl_convert_meta_chars_to_ascii; extern int _rl_output_meta_chars; extern int _rl_complete_show_all; #if defined (PAREN_MATCHING) extern int rl_blink_matching_paren; #endif /* PAREN_MATCHING */ #if defined (VISIBLE_STATS) extern int rl_visible_stats; #endif /* VISIBLE_STATS */ extern int rl_complete_with_tilde_expansion; extern int rl_completion_query_items; #if defined (VI_MODE) extern char *rl_vi_comment_begin; #endif extern int rl_explicit_arg; extern int rl_editing_mode; extern unsigned short _rl_parsing_conditionalized_out; extern Keymap _rl_keymap; extern char *possible_control_prefixes[], *possible_meta_prefixes[]; extern char **rl_funmap_names (); /* Forward declarations */ void rl_set_keymap_from_edit_mode (); static int glean_key_from_name (); #if defined (HAVE_STRCASECMP) #define stricmp strcasecmp #define strnicmp strncasecmp #else static int stricmp (), strnicmp (); #endif #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Binding keys */ /* */ /* **************************************************************** */ /* rl_add_defun (char *name, Function *function, int key) Add NAME to the list of named functions. Make FUNCTION be the function that gets called. If KEY is not -1, then bind it. */ rl_add_defun (name, function, key) char *name; Function *function; int key; { if (key != -1) rl_bind_key (key, function); rl_add_funmap_entry (name, function); return 0; } /* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */ int rl_bind_key (key, function) int key; Function *function; { if (key < 0) return (key); if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii) { if (_rl_keymap[ESC].type == ISKMAP) { Keymap escmap; escmap = FUNCTION_TO_KEYMAP (_rl_keymap, ESC); key = UNMETA (key); escmap[key].type = ISFUNC; escmap[key].function = function; return (0); } return (key); } _rl_keymap[key].type = ISFUNC; _rl_keymap[key].function = function; return (0); } /* Bind KEY to FUNCTION in MAP. Returns non-zero in case of invalid KEY. */ int rl_bind_key_in_map (key, function, map) int key; Function *function; Keymap map; { int result; Keymap oldmap = _rl_keymap; _rl_keymap = map; result = rl_bind_key (key, function); _rl_keymap = oldmap; return (result); } /* Make KEY do nothing in the currently selected keymap. Returns non-zero in case of error. */ int rl_unbind_key (key) int key; { return (rl_bind_key (key, (Function *)NULL)); } /* Make KEY do nothing in MAP. Returns non-zero in case of error. */ int rl_unbind_key_in_map (key, map) int key; Keymap map; { return (rl_bind_key_in_map (key, (Function *)NULL, map)); } /* Bind the key sequence represented by the string KEYSEQ to FUNCTION. This makes new keymaps as necessary. The initial place to do bindings is in MAP. */ rl_set_key (keyseq, function, map) char *keyseq; Function *function; Keymap map; { return (rl_generic_bind (ISFUNC, keyseq, function, map)); } /* Bind the key sequence represented by the string KEYSEQ to the string of characters MACRO. This makes new keymaps as necessary. The initial place to do bindings is in MAP. */ rl_macro_bind (keyseq, macro, map) char *keyseq, *macro; Keymap map; { char *macro_keys; int macro_keys_len; macro_keys = (char *)xmalloc ((2 * strlen (macro)) + 1); if (rl_translate_keyseq (macro, macro_keys, ¯o_keys_len)) { free (macro_keys); return -1; } rl_generic_bind (ISMACR, keyseq, macro_keys, map); return 0; } /* Bind the key sequence represented by the string KEYSEQ to the arbitrary pointer DATA. TYPE says what kind of data is pointed to by DATA, right now this can be a function (ISFUNC), a macro (ISMACR), or a keymap (ISKMAP). This makes new keymaps as necessary. The initial place to do bindings is in MAP. */ rl_generic_bind (type, keyseq, data, map) int type; char *keyseq, *data; Keymap map; { char *keys; int keys_len; register int i; /* If no keys to bind to, exit right away. */ if (!keyseq || !*keyseq) { if (type == ISMACR) free (data); return -1; } keys = xmalloc (1 + (2 * strlen (keyseq))); /* Translate the ASCII representation of KEYSEQ into an array of characters. Stuff the characters into KEYS, and the length of KEYS into KEYS_LEN. */ if (rl_translate_keyseq (keyseq, keys, &keys_len)) { free (keys); return -1; } /* Bind keys, making new keymaps as necessary. */ for (i = 0; i < keys_len; i++) { int ic = (int) ((unsigned char)keys[i]); if (_rl_convert_meta_chars_to_ascii && META_CHAR (ic)) { ic = UNMETA (ic); if (map[ESC].type == ISKMAP) map = FUNCTION_TO_KEYMAP (map, ESC); } if ((i + 1) < keys_len) { if (map[ic].type != ISKMAP) { if (map[ic].type == ISMACR) free ((char *)map[ic].function); map[ic].type = ISKMAP; map[ic].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap()); } map = FUNCTION_TO_KEYMAP (map, ic); } else { if (map[ic].type == ISMACR) free ((char *)map[ic].function); map[ic].function = KEYMAP_TO_FUNCTION (data); map[ic].type = type; } } free (keys); return 0; } /* Translate the ASCII representation of SEQ, stuffing the values into ARRAY, an array of characters. LEN gets the final length of ARRAY. Return non-zero if there was an error parsing SEQ. */ rl_translate_keyseq (seq, array, len) char *seq, *array; int *len; { register int i, c, l = 0; for (i = 0; c = seq[i]; i++) { if (c == '\\') { c = seq[++i]; if (!c) break; if (((c == 'C' || c == 'M') && seq[i + 1] == '-') || (c == 'e')) { /* Handle special case of backwards define. */ if (strncmp (&seq[i], "C-\\M-", 5) == 0) { array[l++] = ESC; i += 5; array[l++] = CTRL (to_upper (seq[i])); if (!seq[i]) i--; continue; } switch (c) { case 'M': i++; array[l++] = ESC; break; case 'C': i += 2; /* Special hack for C-?... */ if (seq[i] == '?') array[l++] = RUBOUT; else array[l++] = CTRL (to_upper (seq[i])); break; case 'e': array[l++] = ESC; } continue; } } array[l++] = c; } *len = l; array[l] = '\0'; return (0); } /* Return a pointer to the function that STRING represents. If STRING doesn't have a matching function, then a NULL pointer is returned. */ Function * rl_named_function (string) char *string; { register int i; rl_initialize_funmap (); for (i = 0; funmap[i]; i++) if (stricmp (funmap[i]->name, string) == 0) return (funmap[i]->function); return ((Function *)NULL); } /* Return the function (or macro) definition which would be invoked via KEYSEQ if executed in MAP. If MAP is NULL, then the current keymap is used. TYPE, if non-NULL, is a pointer to an int which will receive the type of the object pointed to. One of ISFUNC (function), ISKMAP (keymap), or ISMACR (macro). */ Function * rl_function_of_keyseq (keyseq, map, type) char *keyseq; Keymap map; int *type; { register int i; if (!map) map = _rl_keymap; for (i = 0; keyseq && keyseq[i]; i++) { int ic = keyseq[i]; if (META_CHAR (ic) && _rl_convert_meta_chars_to_ascii) { if (map[ESC].type != ISKMAP) { if (type) *type = map[ESC].type; return (map[ESC].function); } else { map = FUNCTION_TO_KEYMAP (map, ESC); ic = UNMETA (ic); } } if (map[ic].type == ISKMAP) { /* If this is the last key in the key sequence, return the map. */ if (!keyseq[i + 1]) { if (type) *type = ISKMAP; return (map[ic].function); } else map = FUNCTION_TO_KEYMAP (map, ic); } else { if (type) *type = map[ic].type; return (map[ic].function); } } return ((Function *) NULL); } /* The last key bindings file read. */ static char *last_readline_init_file = (char *)NULL; /* Re-read the current keybindings file. */ rl_re_read_init_file (count, ignore) int count, ignore; { int r; r = rl_read_init_file ((char *)NULL); rl_set_keymap_from_edit_mode (); return r; } /* Do key bindings from a file. If FILENAME is NULL it defaults to the first non-null filename from this list: 1. the filename used for the previous call 2. the value of the shell variable `INPUTRC' 3. ~/.inputrc If the file existed and could be opened and read, 0 is returned, otherwise errno is returned. */ int rl_read_init_file (filename) char *filename; { register int i; char *buffer, *openname, *line, *end; struct stat finfo; int file; /* Default the filename. */ if (!filename) { filename = last_readline_init_file; if (!filename) filename = getenv ("INPUTRC"); if (!filename) filename = DEFAULT_INPUTRC; } if (!*filename) filename = DEFAULT_INPUTRC; openname = tilde_expand (filename); if ((stat (openname, &finfo) < 0) || (file = open (openname, O_RDONLY, 0666)) < 0) { free (openname); return (errno); } else free (openname); if (filename != last_readline_init_file) { if (last_readline_init_file) free (last_readline_init_file); last_readline_init_file = savestring (filename); } /* Read the file into BUFFER. */ buffer = (char *)xmalloc ((int)finfo.st_size + 1); i = read (file, buffer, finfo.st_size); close (file); if (i != finfo.st_size) return (errno); /* Loop over the lines in the file. Lines that start with `#' are comments; all other lines are commands for readline initialization. */ line = buffer; end = buffer + finfo.st_size; while (line < end) { /* Find the end of this line. */ for (i = 0; line + i != end && line[i] != '\n'; i++); /* Mark end of line. */ line[i] = '\0'; /* Skip leading whitespace. */ while (*line && whitespace (*line)) { line++; i--; } /* If the line is not a comment, then parse it. */ if (*line && *line != '#') rl_parse_and_bind (line); /* Move to the next line. */ line += i + 1; } free (buffer); return (0); } /* **************************************************************** */ /* */ /* Parser Directives */ /* */ /* **************************************************************** */ /* Conditionals. */ /* Calling programs set this to have their argv[0]. */ char *rl_readline_name = "other"; /* Stack of previous values of parsing_conditionalized_out. */ static unsigned char *if_stack = (unsigned char *)NULL; static int if_stack_depth = 0; static int if_stack_size = 0; /* Push _rl_parsing_conditionalized_out, and set parser state based on ARGS. */ static int parser_if (args) char *args; { register int i; /* Push parser state. */ if (if_stack_depth + 1 >= if_stack_size) { if (!if_stack) if_stack = (unsigned char *)xmalloc (if_stack_size = 20); else if_stack = (unsigned char *)xrealloc (if_stack, if_stack_size += 20); } if_stack[if_stack_depth++] = _rl_parsing_conditionalized_out; /* If parsing is turned off, then nothing can turn it back on except for finding the matching endif. In that case, return right now. */ if (_rl_parsing_conditionalized_out) return 0; /* Isolate first argument. */ for (i = 0; args[i] && !whitespace (args[i]); i++); if (args[i]) args[i++] = '\0'; /* Handle "if term=foo" and "if mode=emacs" constructs. If this isn't term=foo, or mode=emacs, then check to see if the first word in ARGS is the same as the value stored in rl_readline_name. */ if (rl_terminal_name && strnicmp (args, "term=", 5) == 0) { char *tem, *tname; /* Terminals like "aaa-60" are equivalent to "aaa". */ tname = savestring (rl_terminal_name); tem = strchr (tname, '-'); if (tem) *tem = '\0'; /* Test the `long' and `short' forms of the terminal name so that if someone has a `sun-cmd' and does not want to have bindings that will be executed if the terminal is a `sun', they can put `$if term=sun-cmd' into their .inputrc. */ if ((stricmp (args + 5, tname) == 0) || (stricmp (args + 5, rl_terminal_name) == 0)) _rl_parsing_conditionalized_out = 0; else _rl_parsing_conditionalized_out = 1; free (tname); } #if defined (VI_MODE) else if (strnicmp (args, "mode=", 5) == 0) { int mode; if (stricmp (args + 5, "emacs") == 0) mode = emacs_mode; else if (stricmp (args + 5, "vi") == 0) mode = vi_mode; else mode = no_mode; if (mode == rl_editing_mode) _rl_parsing_conditionalized_out = 0; else _rl_parsing_conditionalized_out = 1; } #endif /* VI_MODE */ /* Check to see if the first word in ARGS is the same as the value stored in rl_readline_name. */ else if (stricmp (args, rl_readline_name) == 0) _rl_parsing_conditionalized_out = 0; else _rl_parsing_conditionalized_out = 1; return 0; } /* Invert the current parser state if there is anything on the stack. */ static int parser_else (args) char *args; { register int i; if (!if_stack_depth) { /* Error message? */ return 0; } /* Check the previous (n - 1) levels of the stack to make sure that we haven't previously turned off parsing. */ for (i = 0; i < if_stack_depth - 1; i++) if (if_stack[i] == 1) return 0; /* Invert the state of parsing if at top level. */ _rl_parsing_conditionalized_out = !_rl_parsing_conditionalized_out; return 0; } /* Terminate a conditional, popping the value of _rl_parsing_conditionalized_out from the stack. */ static int parser_endif (args) char *args; { if (if_stack_depth) _rl_parsing_conditionalized_out = if_stack[--if_stack_depth]; else { /* *** What, no error message? *** */ } return 0; } /* Associate textual names with actual functions. */ static struct { char *name; Function *function; } parser_directives [] = { { "if", parser_if }, { "endif", parser_endif }, { "else", parser_else }, { (char *)0x0, (Function *)0x0 } }; /* Handle a parser directive. STATEMENT is the line of the directive without any leading `$'. */ static int handle_parser_directive (statement) char *statement; { register int i; char *directive, *args; /* Isolate the actual directive. */ /* Skip whitespace. */ for (i = 0; whitespace (statement[i]); i++); directive = &statement[i]; for (; statement[i] && !whitespace (statement[i]); i++); if (statement[i]) statement[i++] = '\0'; for (; statement[i] && whitespace (statement[i]); i++); args = &statement[i]; /* Lookup the command, and act on it. */ for (i = 0; parser_directives[i].name; i++) if (stricmp (directive, parser_directives[i].name) == 0) { (*parser_directives[i].function) (args); return (0); } /* *** Should an error message be output? */ return (1); } static int substring_member_of_array (); /* Read the binding command from STRING and perform it. A key binding command looks like: Keyname: function-name\0, a variable binding command looks like: set variable value. A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */ rl_parse_and_bind (string) char *string; { char *funname, *kname; register int c, i; int key, equivalency; while (string && whitespace (*string)) string++; if (!string || !*string || *string == '#') return 0; /* If this is a parser directive, act on it. */ if (*string == '$') { handle_parser_directive (&string[1]); return 0; } /* If we aren't supposed to be parsing right now, then we're done. */ if (_rl_parsing_conditionalized_out) return 0; i = 0; /* If this keyname is a complex key expression surrounded by quotes, advance to after the matching close quote. This code allows the backslash to quote characters in the key expression. */ if (*string == '"') { int passc = 0; for (i = 1; c = string[i]; i++) { if (passc) { passc = 0; continue; } if (c == '\\') { passc++; continue; } if (c == '"') break; } } /* Advance to the colon (:) or whitespace which separates the two objects. */ for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ ); equivalency = (c == ':' && string[i + 1] == '='); /* Mark the end of the command (or keyname). */ if (string[i]) string[i++] = '\0'; /* If doing assignment, skip the '=' sign as well. */ if (equivalency) string[i++] = '\0'; /* If this is a command to set a variable, then do that. */ if (stricmp (string, "set") == 0) { char *var = string + i; char *value; /* Make VAR point to start of variable name. */ while (*var && whitespace (*var)) var++; /* Make value point to start of value string. */ value = var; while (*value && !whitespace (*value)) value++; if (*value) *value++ = '\0'; while (*value && whitespace (*value)) value++; rl_variable_bind (var, value); return 0; } /* Skip any whitespace between keyname and funname. */ for (; string[i] && whitespace (string[i]); i++); funname = &string[i]; /* Now isolate funname. For straight function names just look for whitespace, since that will signify the end of the string. But this could be a macro definition. In that case, the string is quoted, so skip to the matching delimiter. We allow the backslash to quote the delimiter characters in the macro body. */ /* This code exists to allow whitespace in macro expansions, which would otherwise be gobbled up by the next `for' loop.*/ /* XXX - it may be desirable to allow backslash quoting only if " is the quoted string delimiter, like the shell. */ if (*funname == '\'' || *funname == '"') { int delimiter = string[i++]; int passc = 0; for (; c = string[i]; i++) { if (passc) { passc = 0; continue; } if (c == '\\') { passc = 1; continue; } if (c == delimiter) break; } if (c) i++; } /* Advance to the end of the string. */ for (; string[i] && !whitespace (string[i]); i++); /* No extra whitespace at the end of the string. */ string[i] = '\0'; /* Handle equivalency bindings here. Make the left-hand side be exactly whatever the right-hand evaluates to, including keymaps. */ if (equivalency) { return 0; } /* If this is a new-style key-binding, then do the binding with rl_set_key (). Otherwise, let the older code deal with it. */ if (*string == '"') { char *seq = xmalloc (1 + strlen (string)); register int j, k = 0; int passc = 0; for (j = 1; string[j]; j++) { /* Allow backslash to quote characters, but leave them in place. This allows a string to end with a backslash quoting another backslash, or with a backslash quoting a double quote. The backslashes are left in place for rl_translate_keyseq (). */ if (passc || (string[j] == '\\')) { seq[k++] = string[j]; passc = !passc; continue; } if (string[j] == '"') break; seq[k++] = string[j]; } seq[k] = '\0'; /* Binding macro? */ if (*funname == '\'' || *funname == '"') { j = strlen (funname); /* Remove the delimiting quotes from each end of FUNNAME. */ if (j && funname[j - 1] == *funname) funname[j - 1] = '\0'; rl_macro_bind (seq, &funname[1], _rl_keymap); } else rl_set_key (seq, rl_named_function (funname), _rl_keymap); free (seq); return 0; } /* Get the actual character we want to deal with. */ kname = strrchr (string, '-'); if (!kname) kname = string; else kname++; key = glean_key_from_name (kname); /* Add in control and meta bits. */ if (substring_member_of_array (string, possible_control_prefixes)) key = CTRL (to_upper (key)); if (substring_member_of_array (string, possible_meta_prefixes)) key = META (key); /* Temporary. Handle old-style keyname with macro-binding. */ if (*funname == '\'' || *funname == '"') { char seq[2]; int fl = strlen (funname); seq[0] = key; seq[1] = '\0'; if (fl && funname[fl - 1] == *funname) funname[fl - 1] = '\0'; rl_macro_bind (seq, &funname[1], _rl_keymap); } #if defined (PREFIX_META_HACK) /* Ugly, but working hack to keep prefix-meta around. */ else if (stricmp (funname, "prefix-meta") == 0) { char seq[2]; seq[0] = key; seq[1] = '\0'; rl_generic_bind (ISKMAP, seq, (char *)emacs_meta_keymap, _rl_keymap); } #endif /* PREFIX_META_HACK */ else rl_bind_key (key, rl_named_function (funname)); return 0; } /* Simple structure for boolean readline variables (i.e., those that can have one of two values; either "On" or 1 for truth, or "Off" or 0 for false. */ static struct { char *name; int *value; } boolean_varlist [] = { { "horizontal-scroll-mode", &_rl_horizontal_scroll_mode }, { "mark-modified-lines", &_rl_mark_modified_lines }, { "meta-flag", &_rl_meta_flag }, #if defined (PAREN_MATCHING) { "blink-matching-paren", &rl_blink_matching_paren }, #endif { "convert-meta", &_rl_convert_meta_chars_to_ascii }, { "show-all-if-ambiguous", &_rl_complete_show_all }, { "output-meta", &_rl_output_meta_chars }, #if defined (VISIBLE_STATS) { "visible-stats", &rl_visible_stats }, #endif /* VISIBLE_STATS */ { "expand-tilde", &rl_complete_with_tilde_expansion }, { (char *)NULL, (int *)NULL } }; rl_variable_bind (name, value) char *name, *value; { register int i; /* Check for simple variables first. */ for (i = 0; boolean_varlist[i].name; i++) { if (stricmp (name, boolean_varlist[i].name) == 0) { /* A variable is TRUE if the "value" is "on", "1" or "". */ if ((!*value) || (stricmp (value, "On") == 0) || (value[0] == '1' && value[1] == '\0')) *boolean_varlist[i].value = 1; else *boolean_varlist[i].value = 0; return 0; } } /* Not a boolean variable, so check for specials. */ /* Editing mode change? */ if (stricmp (name, "editing-mode") == 0) { if (strnicmp (value, "vi", 2) == 0) { #if defined (VI_MODE) _rl_keymap = vi_insertion_keymap; rl_editing_mode = vi_mode; #endif /* VI_MODE */ } else if (strnicmp (value, "emacs", 5) == 0) { _rl_keymap = emacs_standard_keymap; rl_editing_mode = emacs_mode; } } /* Comment string change? */ else if (stricmp (name, "comment-begin") == 0) { #if defined (VI_MODE) if (*value) { if (rl_vi_comment_begin) free (rl_vi_comment_begin); rl_vi_comment_begin = savestring (value); } #endif /* VI_MODE */ } else if (stricmp (name, "completion-query-items") == 0) { int nval = 100; if (*value) { nval = atoi (value); if (nval < 0) nval = 0; } rl_completion_query_items = nval; } else if (stricmp (name, "keymap") == 0) { Keymap kmap; kmap = rl_get_keymap_by_name (value); if (kmap) rl_set_keymap (kmap); } else if (stricmp (name, "bell-style") == 0) { if (!*value) _rl_bell_preference = AUDIBLE_BELL; else { if (stricmp (value, "none") == 0 || stricmp (value, "off") == 0) _rl_bell_preference = NO_BELL; else if (stricmp (value, "audible") == 0 || stricmp (value, "on") == 0) _rl_bell_preference = AUDIBLE_BELL; else if (stricmp (value, "visible") == 0) _rl_bell_preference = VISIBLE_BELL; } } else if (stricmp (name, "prefer-visible-bell") == 0) { /* Backwards compatibility. */ if (*value && (stricmp (value, "on") == 0 || (*value == '1' && !value[1]))) _rl_bell_preference = VISIBLE_BELL; else _rl_bell_preference = AUDIBLE_BELL; } return 0; } /* Return the character which matches NAME. For example, `Space' returns ' '. */ typedef struct { char *name; int value; } assoc_list; static assoc_list name_key_alist[] = { { "DEL", 0x7f }, { "ESC", '\033' }, { "Escape", '\033' }, { "LFD", '\n' }, { "Newline", '\n' }, { "RET", '\r' }, { "Return", '\r' }, { "Rubout", 0x7f }, { "SPC", ' ' }, { "Space", ' ' }, { "Tab", 0x09 }, { (char *)0x0, 0 } }; static int glean_key_from_name (name) char *name; { register int i; for (i = 0; name_key_alist[i].name; i++) if (stricmp (name, name_key_alist[i].name) == 0) return (name_key_alist[i].value); return (*(unsigned char *)name); /* XXX was return (*name) */ } /* Auxiliary functions to manage keymaps. */ static struct { char *name; Keymap map; } keymap_names[] = { { "emacs", emacs_standard_keymap }, { "emacs-standard", emacs_standard_keymap }, { "emacs-meta", emacs_meta_keymap }, { "emacs-ctlx", emacs_ctlx_keymap }, #if defined (VI_MODE) { "vi", vi_movement_keymap }, { "vi-move", vi_movement_keymap }, { "vi-command", vi_movement_keymap }, { "vi-insert", vi_insertion_keymap }, #endif /* VI_MODE */ { (char *)0x0, (Keymap)0x0 } }; Keymap rl_get_keymap_by_name (name) char *name; { register int i; for (i = 0; keymap_names[i].name; i++) if (strcmp (name, keymap_names[i].name) == 0) return (keymap_names[i].map); return ((Keymap) NULL); } void rl_set_keymap (map) Keymap map; { if (map) _rl_keymap = map; } Keymap rl_get_keymap () { return (_rl_keymap); } void rl_set_keymap_from_edit_mode () { if (rl_editing_mode == emacs_mode) _rl_keymap = emacs_standard_keymap; #if defined (VI_MODE) else if (rl_editing_mode == vi_mode) _rl_keymap = vi_insertion_keymap; #endif /* VI_MODE */ } /* **************************************************************** */ /* */ /* Key Binding and Function Information */ /* */ /* **************************************************************** */ /* Each of the following functions produces information about the state of keybindings and functions known to Readline. The info is always printed to rl_outstream, and in such a way that it can be read back in (i.e., passed to rl_parse_and_bind (). */ /* Print the names of functions known to Readline. */ void rl_list_funmap_names (count, ignore) int count, ignore; { register int i; char **funmap_names; funmap_names = rl_funmap_names (); if (!funmap_names) return; for (i = 0; funmap_names[i]; i++) fprintf (rl_outstream, "%s\n", funmap_names[i]); free (funmap_names); } /* Return a NULL terminated array of strings which represent the key sequences that are used to invoke FUNCTION in MAP. */ char ** rl_invoking_keyseqs_in_map (function, map) Function *function; Keymap map; { register int key; char **result; int result_index, result_size; result = (char **)NULL; result_index = result_size = 0; for (key = 0; key < 128; key++) { switch (map[key].type) { case ISMACR: /* Macros match, if, and only if, the pointers are identical. Thus, they are treated exactly like functions in here. */ case ISFUNC: /* If the function in the keymap is the one we are looking for, then add the current KEY to the list of invoking keys. */ if (map[key].function == function) { char *keyname = (char *)xmalloc (5); if (CTRL_CHAR (key)) sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key))); else if (key == RUBOUT) sprintf (keyname, "\\C-?"); else if (key == '\\' || key == '"') { keyname[0] = '\\'; keyname[1] = (char) key; keyname[2] = '\0'; } else { keyname[0] = (char) key; keyname[1] = '\0'; } if (result_index + 2 > result_size) result = (char **) xrealloc (result, (result_size += 10) * sizeof (char *)); result[result_index++] = keyname; result[result_index] = (char *)NULL; } break; case ISKMAP: { char **seqs = (char **)NULL; /* Find the list of keyseqs in this map which have FUNCTION as their target. Add the key sequences found to RESULT. */ if (map[key].function) seqs = rl_invoking_keyseqs_in_map (function, FUNCTION_TO_KEYMAP (map, key)); if (seqs) { register int i; for (i = 0; seqs[i]; i++) { char *keyname = (char *)xmalloc (6 + strlen (seqs[i])); if (key == ESC) sprintf (keyname, "\\e"); else if (CTRL_CHAR (key)) sprintf (keyname, "\\C-%c", to_lower (UNCTRL (key))); else if (key == RUBOUT) sprintf (keyname, "\\C-?"); else if (key == '\\' || key == '"') { keyname[0] = '\\'; keyname[1] = (char) key; keyname[2] = '\0'; } else { keyname[0] = (char) key; keyname[1] = '\0'; } strcat (keyname, seqs[i]); free (seqs[i]); if (result_index + 2 > result_size) result = (char **) xrealloc (result, (result_size += 10) * sizeof (char *)); result[result_index++] = keyname; result[result_index] = (char *)NULL; } free (seqs); } } break; } } return (result); } /* Return a NULL terminated array of strings which represent the key sequences that can be used to invoke FUNCTION using the current keymap. */ char ** rl_invoking_keyseqs (function) Function *function; { return (rl_invoking_keyseqs_in_map (function, _rl_keymap)); } /* Print all of the current functions and their bindings to rl_outstream. If an explicit argument is given, then print the output in such a way that it can be read back in. */ int rl_dump_functions (count, key) int count, key; { rl_function_dumper (rl_explicit_arg); rl_on_new_line (); return (0); } /* Print all of the functions and their bindings to rl_outstream. If PRINT_READABLY is non-zero, then print the output in such a way that it can be read back in. */ void rl_function_dumper (print_readably) int print_readably; { register int i; char **names; char *name; names = rl_funmap_names (); fprintf (rl_outstream, "\n"); for (i = 0; name = names[i]; i++) { Function *function; char **invokers; function = rl_named_function (name); invokers = rl_invoking_keyseqs_in_map (function, _rl_keymap); if (print_readably) { if (!invokers) fprintf (rl_outstream, "# %s (not bound)\n", name); else { register int j; for (j = 0; invokers[j]; j++) { fprintf (rl_outstream, "\"%s\": %s\n", invokers[j], name); free (invokers[j]); } free (invokers); } } else { if (!invokers) fprintf (rl_outstream, "%s is not bound to any keys\n", name); else { register int j; fprintf (rl_outstream, "%s can be found on ", name); for (j = 0; invokers[j] && j < 5; j++) { fprintf (rl_outstream, "\"%s\"%s", invokers[j], invokers[j + 1] ? ", " : ".\n"); } if (j == 5 && invokers[j]) fprintf (rl_outstream, "...\n"); for (j = 0; invokers[j]; j++) free (invokers[j]); free (invokers); } } } } /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound. */ void _rl_bind_if_unbound (keyseq, default_func) char *keyseq; Function *default_func; { Function *func; if (keyseq) { func = rl_function_of_keyseq (keyseq, _rl_keymap, (int *)NULL); if (!func || func == rl_do_lowercase_version) rl_set_key (keyseq, default_func, _rl_keymap); } } /* **************************************************************** */ /* */ /* String Utility Functions */ /* */ /* **************************************************************** */ static char *strindex (); /* Return non-zero if any members of ARRAY are a substring in STRING. */ static int substring_member_of_array (string, array) char *string, **array; { while (*array) { if (strindex (string, *array)) return (1); array++; } return (0); } #if !defined (HAVE_STRCASECMP) /* Whoops, Unix doesn't have strnicmp. */ /* Compare at most COUNT characters from string1 to string2. Case doesn't matter. */ static int strnicmp (string1, string2, count) char *string1, *string2; int count; { register char ch1, ch2; while (count) { ch1 = *string1++; ch2 = *string2++; if (to_upper(ch1) == to_upper(ch2)) count--; else break; } return (count); } /* strcmp (), but caseless. */ static int stricmp (string1, string2) char *string1, *string2; { register char ch1, ch2; while (*string1 && *string2) { ch1 = *string1++; ch2 = *string2++; if (to_upper(ch1) != to_upper(ch2)) return (1); } return (*string1 - *string2); } #endif /* !HAVE_STRCASECMP */ /* Determine if s2 occurs in s1. If so, return a pointer to the match in s1. The compare is case insensitive. */ static char * strindex (s1, s2) register char *s1, *s2; { register int i, l = strlen (s2); register int len = strlen (s1); for (i = 0; (len - i) >= l; i++) if (strnicmp (s1 + i, s2, l) == 0) return (s1 + i); return ((char *)NULL); } lafe/readline/display.c100644 325 24 106103 6106101043 13343 0ustar dlduser/* display.c -- readline redisplay facility. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" /* Some standard library routines. */ #include "readline.h" #include "history.h" #if !defined (strchr) && !defined (__STDC__) extern char *strchr (), *strrchr (); #endif /* !strchr && !__STDC__ */ /* Global and pseudo-global variables and functions imported from readline.c. */ extern char *rl_prompt; extern int readline_echoing_p; extern char *term_clreol, *term_im, *term_ic, *term_ei, *term_DC; /* Termcap variables. */ extern char *term_up, *term_dc, *term_cr, *term_IC; extern int screenheight, screenwidth, screenchars; extern int terminal_can_insert, term_xn; extern void _rl_output_some_chars (); extern int _rl_output_character_function (); extern int _rl_output_meta_chars; extern int _rl_horizontal_scroll_mode; extern int _rl_mark_modified_lines; extern int _rl_prefer_visible_bell; /* Pseudo-global functions (local to the readline library) exported by this file. */ void _rl_move_cursor_relative (), _rl_output_some_chars (); void _rl_move_vert (); static void update_line (), clear_to_eol (), space_to_eol (); static void delete_chars (), insert_some_chars (); extern char *xmalloc (), *xrealloc (); /* Heuristic used to decide whether it is faster to move from CUR to NEW by backing up or outputting a carriage return and moving forward. */ #define CR_FASTER(new, cur) (((new) + 1) < ((cur) - (new))) /* **************************************************************** */ /* */ /* Display stuff */ /* */ /* **************************************************************** */ /* This is the stuff that is hard for me. I never seem to write good display routines in C. Let's see how I do this time. */ /* (PWP) Well... Good for a simple line updater, but totally ignores the problems of input lines longer than the screen width. update_line and the code that calls it makes a multiple line, automatically wrapping line update. Careful attention needs to be paid to the vertical position variables. */ /* Keep two buffers; one which reflects the current contents of the screen, and the other to draw what we think the new contents should be. Then compare the buffers, and make whatever changes to the screen itself that we should. Finally, make the buffer that we just drew into be the one which reflects the current contents of the screen, and place the cursor where it belongs. Commands that want to can fix the display themselves, and then let this function know that the display has been fixed by setting the RL_DISPLAY_FIXED variable. This is good for efficiency. */ /* Global variables declared here. */ /* What YOU turn on when you have handled all redisplay yourself. */ int rl_display_fixed = 0; /* The stuff that gets printed out before the actual text of the line. This is usually pointing to rl_prompt. */ char *rl_display_prompt = (char *)NULL; /* Pseudo-global variables declared here. */ /* The visible cursor position. If you print some text, adjust this. */ int _rl_last_c_pos = 0; int _rl_last_v_pos = 0; /* Number of lines currently on screen minus 1. */ int _rl_vis_botlin = 0; /* Variables used only in this file. */ /* The last left edge of text that was displayed. This is used when doing horizontal scrolling. It shifts in thirds of a screenwidth. */ static int last_lmargin = 0; /* The line display buffers. One is the line currently displayed on the screen. The other is the line about to be displayed. */ static char *visible_line = (char *)NULL; static char *invisible_line = (char *)NULL; /* A buffer for `modeline' messages. */ static char msg_buf[128]; /* Non-zero forces the redisplay even if we thought it was unnecessary. */ static int forced_display = 0; /* Default and initial buffer size. Can grow. */ static int line_size = 1024; static char *last_prompt_string = (char *)NULL; static char *local_prompt, *local_prompt_prefix; static int visible_length, prefix_length; /* The number of invisible characters in the line currently being displayed on the screen. */ static int visible_wrap_offset = 0; /* The length (buffer offset) of the first line of the last (possibly multi-line) buffer displayed on the screen. */ static int visible_first_line_len = 0; /* Expand the prompt string S and return the number of visible characters in *LP, if LP is not null. This is currently more-or-less a placeholder for expansion. */ /* Current implementation: \001 (^A) start non-visible characters \002 (^B) end non-visible characters all characters except \001 and \002 (following a \001) are copied to the returned string; all characters except those between \001 and \002 are assumed to be `visible'. */ static char * expand_prompt (pmt, lp) char *pmt; int *lp; { char *r, *ret, *p; int l, rl, ignoring; /* Short-circuit if we can. */ if (strchr (pmt, RL_PROMPT_START_IGNORE) == 0) { r = savestring (pmt); if (lp) *lp = strlen (r); return r; } l = strlen (pmt); r = ret = xmalloc (l + 1); for (rl = ignoring = 0, p = pmt; p && *p; p++) { /* This code strips the invisible character string markers RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE */ if (*p == RL_PROMPT_START_IGNORE) { ignoring++; continue; } else if (ignoring && *p == RL_PROMPT_END_IGNORE) { ignoring = 0; continue; } else { *r++ = *p; if (!ignoring) rl++; } } *r = '\0'; if (lp) *lp = rl; return ret; } /* * Expand the prompt string into the various display components, if * necessary. * * local_prompt = expanded last line of string in rl_display_prompt * (portion after the final newline) * local_prompt_prefix = portion before last newline of rl_display_prompt, * expanded via expand_prompt * visible_length = number of visible characters in local_prompt * prefix_length = number of visible characters in local_prompt_prefix * * This function is called once per call to readline(). It may also be * called arbitrarily to expand the primary prompt. * * The return value is the number of visible characters on the last line * of the (possibly multi-line) prompt. */ int rl_expand_prompt (prompt) char *prompt; { char *p, *t; int c; /* Clear out any saved values. */ if (local_prompt) free (local_prompt); if (local_prompt_prefix) free (local_prompt_prefix); local_prompt = local_prompt_prefix = (char *)0; p = strrchr (prompt, '\n'); if (!p) { /* The prompt is only one line. */ local_prompt = expand_prompt (prompt, &visible_length); local_prompt_prefix = (char *)0; return (visible_length); } else { /* The prompt spans multiple lines. */ t = ++p; local_prompt = expand_prompt (p, &visible_length); c = *t; *t = '\0'; /* The portion of the prompt string up to and including the final newline is now null-terminated. */ local_prompt_prefix = expand_prompt (prompt, &prefix_length); *t = c; return (prefix_length); } } /* Basic redisplay algorithm. */ void rl_redisplay () { register int in, out, c, linenum; register char *line = invisible_line; int c_pos = 0, inv_botlin = 0, wrap_offset, wrap_column; char *prompt_this_line; if (!readline_echoing_p) return; if (!rl_display_prompt) rl_display_prompt = ""; if (!invisible_line) { visible_line = xmalloc (line_size); invisible_line = xmalloc (line_size); line = invisible_line; for (in = 0; in < line_size; in++) { visible_line[in] = 0; invisible_line[in] = 1; } rl_on_new_line (); } /* Draw the line into the buffer. */ c_pos = -1; /* Mark the line as modified or not. We only do this for history lines. */ out = 0; if (_rl_mark_modified_lines && current_history () && rl_undo_list) { line[out++] = '*'; line[out] = '\0'; } /* If someone thought that the redisplay was handled, but the currently visible line has a different modification state than the one about to become visible, then correct the caller's misconception. */ if (visible_line[0] != invisible_line[0]) rl_display_fixed = 0; /* If the prompt to be displayed is the `primary' readline prompt (the one passed to readline()), use the values we have already expanded. If not, use what's already in rl_display_prompt. WRAP_OFFSET is the number of non-visible characters in the prompt string. */ if (rl_display_prompt == rl_prompt) { int local_len = local_prompt ? strlen (local_prompt) : 0; if (local_prompt_prefix && forced_display) _rl_output_some_chars (local_prompt_prefix, strlen (local_prompt_prefix)); if (local_len > 0) strncpy (line + out, local_prompt, local_len); out += local_len; line[out] = '\0'; wrap_offset = local_len - visible_length; } else { int pmtlen; prompt_this_line = strrchr (rl_display_prompt, '\n'); if (!prompt_this_line) prompt_this_line = rl_display_prompt; else { prompt_this_line++; if (forced_display) _rl_output_some_chars (rl_display_prompt, prompt_this_line - rl_display_prompt); } pmtlen = strlen (prompt_this_line); strncpy (line + out, prompt_this_line, pmtlen); out += pmtlen; line[out] = '\0'; wrap_offset = 0; } for (in = 0; in < rl_end; in++) { c = (unsigned char)rl_line_buffer[in]; if (out + 8 >= line_size) /* XXX - 8 for \t */ { line_size *= 2; visible_line = xrealloc (visible_line, line_size); invisible_line = xrealloc (invisible_line, line_size); line = invisible_line; } if (in == rl_point) c_pos = out; if (META_CHAR (c)) { if (_rl_output_meta_chars == 0) { sprintf (line + out, "\\%o", c); out += 4; } else line[out++] = c; } #if defined (DISPLAY_TABS) else if (c == '\t') { register int newout = (out | (int)7) + 1; while (out < newout) line[out++] = ' '; } #endif else if (c < ' ') { line[out++] = '^'; line[out++] = UNCTRL (c); /* XXX was c ^ 0x40 */ } else if (c == 127) { line[out++] = '^'; line[out++] = '?'; } else line[out++] = c; } line[out] = '\0'; if (c_pos < 0) c_pos = out; /* C_POS == position in buffer where cursor should be placed. */ /* PWP: now is when things get a bit hairy. The visible and invisible line buffers are really multiple lines, which would wrap every (screenwidth - 1) characters. Go through each in turn, finding the changed region and updating it. The line order is top to bottom. */ /* If we can move the cursor up and down, then use multiple lines, otherwise, let long lines display in a single terminal line, and horizontally scroll it. */ if (!_rl_horizontal_scroll_mode && term_up && *term_up) { int total_screen_chars = screenchars; int nleft, cursor_linenum, pos, changed_screen_line; if (!rl_display_fixed || forced_display) { forced_display = 0; /* If we have more than a screenful of material to display, then only display a screenful. We should display the last screen, not the first. I'll fix this in a minute. */ if (out >= total_screen_chars) out = total_screen_chars - 1; /* Number of screen lines to display. The first line wraps at (screenwidth + wrap_offset) chars, the rest of the lines have screenwidth chars. */ nleft = out - wrap_offset + term_xn - 1; inv_botlin = (nleft > 0) ? nleft / screenwidth : 0; /* The first line is at character position 0 in the buffer. The second and subsequent lines start at N * screenwidth, offset by OFFSET. OFFSET is wrap_offset for the invisible line and visible_wrap_offset for the line currently displayed. */ #define W_OFFSET(line, offset) ((line) == 0 ? offset : 0) #define L_OFFSET(n, offset) ((n) > 0 ? ((n) * screenwidth) + (offset) : 0) #define VIS_CHARS(line) &visible_line[L_OFFSET((line), visible_wrap_offset)] #define VIS_LINE(line) ((line) > _rl_vis_botlin) ? "" : VIS_CHARS(line) #define INV_LINE(line) &invisible_line[L_OFFSET((line), wrap_offset)] /* For each line in the buffer, do the updating display. */ for (linenum = 0; linenum <= inv_botlin; linenum++) { update_line (VIS_LINE(linenum), INV_LINE(linenum), linenum, screenwidth + W_OFFSET(linenum, visible_wrap_offset), screenwidth + W_OFFSET(linenum, wrap_offset), inv_botlin); /* If this is the line with the prompt, we might need to compensate for invisible characters in the new line. Do this only if there is not more than one new line (which implies that we completely overwrite the old visible line) and the new line is shorter than the old. */ if (linenum == 0 && inv_botlin == 0 && (wrap_offset > visible_wrap_offset) && (_rl_last_c_pos < visible_first_line_len)) { nleft = screenwidth + wrap_offset - _rl_last_c_pos; clear_to_eol (nleft); } /* Since the new first line is now visible, save its length. */ if (linenum == 0) visible_first_line_len = (inv_botlin > 0) ? screenwidth : out - wrap_offset; } /* We may have deleted some lines. If so, clear the left over blank ones at the bottom out. */ if (_rl_vis_botlin > inv_botlin) { char *tt; for (; linenum <= _rl_vis_botlin; linenum++) { tt = VIS_CHARS (linenum); _rl_move_vert (linenum); _rl_move_cursor_relative (0, tt); clear_to_eol ((linenum == _rl_vis_botlin) ? strlen (tt) : screenwidth); } } _rl_vis_botlin = inv_botlin; /* Move the cursor where it should be. */ /* Which line? */ nleft = c_pos - wrap_offset - term_xn + 1; cursor_linenum = (nleft > 0) ? nleft / screenwidth : 0; /* CHANGED_SCREEN_LINE is set to 1 if we have moved to a different screen line during this redisplay. */ changed_screen_line = _rl_last_v_pos != cursor_linenum; if (changed_screen_line) { _rl_move_vert (cursor_linenum); /* If we moved up to the line with the prompt using term_up, the physical cursor position on the screen stays the same, but the buffer position needs to be adjusted to account for invisible characters. */ if (cursor_linenum == 0 && wrap_offset) _rl_last_c_pos += wrap_offset; } /* We have to reprint the prompt if it contains invisible characters, since it's not generally OK to just reprint the characters from the current cursor position. */ nleft = visible_length + wrap_offset; if (cursor_linenum == 0 && wrap_offset > 0 && _rl_last_c_pos > 0 && _rl_last_c_pos <= nleft && local_prompt) { if (term_cr) tputs (term_cr, 1, _rl_output_character_function); _rl_output_some_chars (local_prompt, nleft); _rl_last_c_pos = nleft; } /* Where on that line? And where does that line start in the buffer? */ pos = L_OFFSET(cursor_linenum, wrap_offset); /* nleft == number of characters in the line buffer between the start of the line and the cursor position. */ nleft = c_pos - pos; /* Since backspace() doesn't know about invisible characters in the prompt, and there's no good way to tell it, we compensate for those characters here and call backspace() directly. */ if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos) { backspace (_rl_last_c_pos - nleft); _rl_last_c_pos = nleft; } if (nleft != _rl_last_c_pos) _rl_move_cursor_relative (nleft, &invisible_line[pos]); } } else /* Do horizontal scrolling. */ { #define M_OFFSET(margin, offset) ((margin) == 0 ? offset : 0) int lmargin, ndisp, nleft, phys_c_pos, t; /* Always at top line. */ _rl_last_v_pos = 0; /* Compute where in the buffer the displayed line should start. This will be LMARGIN. */ /* The number of characters that will be displayed before the cursor. */ ndisp = c_pos - wrap_offset; nleft = visible_length + wrap_offset; /* Where the new cursor position will be on the screen. This can be longer than SCREENWIDTH; if it is, lmargin will be adjusted. */ phys_c_pos = c_pos - (last_lmargin ? last_lmargin : wrap_offset); t = screenwidth / 3; /* If the number of characters had already exceeded the screenwidth, last_lmargin will be > 0. */ /* If the number of characters to be displayed is more than the screen width, compute the starting offset so that the cursor is about two-thirds of the way across the screen. */ if (phys_c_pos > screenwidth - 2) { lmargin = c_pos - (2 * t); if (lmargin < 0) lmargin = 0; /* If the left margin would be in the middle of a prompt with invisible characters, don't display the prompt at all. */ if (wrap_offset && lmargin > 0 && lmargin < nleft) lmargin = nleft; } else if (ndisp < screenwidth - 2) /* XXX - was -1 */ lmargin = 0; else if (phys_c_pos < 1) { /* If we are moving back towards the beginning of the line and the last margin is no longer correct, compute a new one. */ lmargin = ((c_pos - 1) / t) * t; /* XXX */ if (wrap_offset && lmargin > 0 && lmargin < nleft) lmargin = nleft; } else lmargin = last_lmargin; /* If the first character on the screen isn't the first character in the display line, indicate this with a special character. */ if (lmargin > 0) line[lmargin] = '<'; /* If SCREENWIDTH characters starting at LMARGIN do not encompass the whole line, indicate that with a special characters at the right edge of the screen. If LMARGIN is 0, we need to take the wrap offset into account. */ t = lmargin + M_OFFSET (lmargin, wrap_offset) + screenwidth; if (t < out) line[t - 1] = '>'; if (!rl_display_fixed || forced_display || lmargin != last_lmargin) { forced_display = 0; update_line (&visible_line[last_lmargin], &invisible_line[lmargin], 0, screenwidth + visible_wrap_offset, screenwidth + (lmargin ? 0 : wrap_offset), 0); /* If the visible new line is shorter than the old, but the number of invisible characters is greater, and we are at the end of the new line, we need to clear to eol. */ t = _rl_last_c_pos - M_OFFSET (lmargin, wrap_offset); if ((M_OFFSET (lmargin, wrap_offset) > visible_wrap_offset) && (_rl_last_c_pos == out) && t < visible_first_line_len) { nleft = screenwidth - t; clear_to_eol (nleft); } visible_first_line_len = out - lmargin - M_OFFSET (lmargin, wrap_offset); if (visible_first_line_len > screenwidth) visible_first_line_len = screenwidth; _rl_move_cursor_relative (c_pos - lmargin, &invisible_line[lmargin]); last_lmargin = lmargin; } } fflush (rl_outstream); /* Swap visible and non-visible lines. */ { char *temp = visible_line; visible_line = invisible_line; invisible_line = temp; rl_display_fixed = 0; /* If we are displaying on a single line, and last_lmargin is > 0, we are not displaying any invisible characters, so set visible_wrap_offset to 0. */ if (_rl_horizontal_scroll_mode && last_lmargin) visible_wrap_offset = 0; else visible_wrap_offset = wrap_offset; } } /* PWP: update_line() is based on finding the middle difference of each line on the screen; vis: /old first difference /beginning of line | /old last same /old EOL v v v v old: eddie> Oh, my little gruntle-buggy is to me, as lurgid as new: eddie> Oh, my little buggy says to me, as lurgid as ^ ^ ^ ^ \beginning of line | \new last same \new end of line \new first difference All are character pointers for the sake of speed. Special cases for no differences, as well as for end of line additions must be handeled. Could be made even smarter, but this works well enough */ static void update_line (old, new, current_line, omax, nmax, inv_botlin) register char *old, *new; int current_line, omax, nmax; { register char *ofd, *ols, *oe, *nfd, *nls, *ne; int temp, lendiff, wsatend, od, nd; /* If we're at the right edge of a terminal that supports xn, we're ready to wrap around, so do so. This fixes problems with knowing the exact cursor position and cut-and-paste with certain terminal emulators. In this calculation, TEMP is the physical screen position of the cursor. */ temp = _rl_last_c_pos - W_OFFSET(_rl_last_v_pos, visible_wrap_offset); if (temp == screenwidth && term_xn && !_rl_horizontal_scroll_mode && _rl_last_v_pos == current_line - 1) { if (new[0]) putc (new[0], rl_outstream); else putc (' ', rl_outstream); _rl_last_c_pos = 1; /* XXX */ _rl_last_v_pos++; if (old[0]) old[0] = new[0]; } /* Find first difference. */ for (ofd = old, nfd = new; (ofd - old < omax) && *ofd && (*ofd == *nfd); ofd++, nfd++) ; /* Move to the end of the screen line. ND and OD are used to keep track of the distance between ne and new and oe and old, respectively, to move a subtraction out of each loop. */ for (od = ofd - old, oe = ofd; od < omax && *oe; oe++, od++); for (nd = nfd - new, ne = nfd; nd < nmax && *ne; ne++, nd++); /* If no difference, continue to next line. */ if (ofd == oe && nfd == ne) return; wsatend = 1; /* flag for trailing whitespace */ ols = oe - 1; /* find last same */ nls = ne - 1; while ((ols > ofd) && (nls > nfd) && (*ols == *nls)) { if (*ols != ' ') wsatend = 0; ols--; nls--; } if (wsatend) { ols = oe; nls = ne; } else if (*ols != *nls) { if (*ols) /* don't step past the NUL */ ols++; if (*nls) nls++; } _rl_move_vert (current_line); /* If this is the first line and there are invisible characters in the prompt string, and the prompt string has not changed, then redraw the entire prompt string. We can only do this reliably if the terminal supports a `cr' capability. This is more than just an efficiency hack -- there is a problem with redrawing portions of the prompt string if they contain terminal escape sequences (like drawing the `unbold' sequence without a corresponding `bold') that manifests itself on certain terminals. */ lendiff = strlen (local_prompt); if (current_line == 0 && !_rl_horizontal_scroll_mode && lendiff > visible_length && _rl_last_c_pos > 0 && (ofd - old) >= lendiff && term_cr) { tputs (term_cr, 1, _rl_output_character_function); _rl_output_some_chars (local_prompt, lendiff); _rl_last_c_pos = lendiff; } _rl_move_cursor_relative (ofd - old, old); /* if (len (new) > len (old)) */ lendiff = (nls - nfd) - (ols - ofd); /* Insert (diff (len (old), len (new)) ch. */ temp = ne - nfd; if (lendiff > 0) { /* Non-zero if we're increasing the number of lines. */ int gl = current_line >= _rl_vis_botlin && inv_botlin > _rl_vis_botlin; /* Sometimes it is cheaper to print the characters rather than use the terminal's capabilities. If we're growing the number of lines, make sure we actually cause the new line to wrap around on auto-wrapping terminals. */ if (terminal_can_insert && ((2 * temp) >= lendiff || term_IC) && (!term_xn || !gl)) { /* If lendiff > visible_length and _rl_last_c_pos == 0 and _rl_horizontal_scroll_mode == 1, inserting the characters with term_IC or term_ic will screw up the screen because of the invisible characters. We need to just draw them. */ if (*ols && (!_rl_horizontal_scroll_mode || _rl_last_c_pos > 0 || lendiff <= visible_length)) { insert_some_chars (nfd, lendiff); _rl_last_c_pos += lendiff; } else { /* At the end of a line the characters do not have to be "inserted". They can just be placed on the screen. */ _rl_output_some_chars (nfd, lendiff); _rl_last_c_pos += lendiff; } /* Copy (new) chars to screen from first diff to last match. */ temp = nls - nfd; if ((temp - lendiff) > 0) { _rl_output_some_chars (nfd + lendiff, temp - lendiff); _rl_last_c_pos += temp - lendiff; } } else { /* cannot insert chars, write to EOL */ _rl_output_some_chars (nfd, temp); _rl_last_c_pos += temp; } } else /* Delete characters from line. */ { /* If possible and inexpensive to use terminal deletion, then do so. */ if (term_dc && (2 * temp) >= -lendiff) { /* If all we're doing is erasing the invisible characters in the prompt string, don't bother. It screws up the assumptions about what's on the screen. */ if (_rl_horizontal_scroll_mode && _rl_last_c_pos == 0 && -lendiff == visible_wrap_offset) lendiff = 0; if (lendiff) delete_chars (-lendiff); /* delete (diff) characters */ /* Copy (new) chars to screen from first diff to last match */ temp = nls - nfd; if (temp > 0) { _rl_output_some_chars (nfd, temp); _rl_last_c_pos += temp; } } /* Otherwise, print over the existing material. */ else { if (temp > 0) { _rl_output_some_chars (nfd, temp); _rl_last_c_pos += temp; } lendiff = (oe - old) - (ne - new); if (term_xn && current_line < inv_botlin) space_to_eol (lendiff); else clear_to_eol (lendiff); } } } /* Tell the update routines that we have moved onto a new (empty) line. */ rl_on_new_line () { if (visible_line) visible_line[0] = '\0'; _rl_last_c_pos = _rl_last_v_pos = 0; _rl_vis_botlin = last_lmargin = 0; return 0; } /* Actually update the display, period. */ rl_forced_update_display () { if (visible_line) { register char *temp = visible_line; while (*temp) *temp++ = '\0'; } rl_on_new_line (); forced_display++; rl_redisplay (); return 0; } /* Move the cursor from _rl_last_c_pos to NEW, which are buffer indices. DATA is the contents of the screen line of interest; i.e., where the movement is being done. */ void _rl_move_cursor_relative (new, data) int new; char *data; { register int i; /* If we don't have to do anything, then return. */ if (_rl_last_c_pos == new) return; /* It may be faster to output a CR, and then move forwards instead of moving backwards. */ /* i == current physical cursor position. */ i = _rl_last_c_pos - W_OFFSET(_rl_last_v_pos, visible_wrap_offset); if (CR_FASTER (new, _rl_last_c_pos) || (term_xn && i == screenwidth)) { #if defined (__MSDOS__) putc ('\r', rl_outstream); #else tputs (term_cr, 1, _rl_output_character_function); #endif /* !__MSDOS__ */ _rl_last_c_pos = 0; } if (_rl_last_c_pos < new) { /* Move the cursor forward. We do it by printing the command to move the cursor forward if there is one, else print that portion of the output buffer again. Which is cheaper? */ /* The above comment is left here for posterity. It is faster to print one character (non-control) than to print a control sequence telling the terminal to move forward one character. That kind of control is for people who don't know what the data is underneath the cursor. */ #if defined (HACK_TERMCAP_MOTION) extern char *term_forward_char; if (term_forward_char) for (i = _rl_last_c_pos; i < new; i++) tputs (term_forward_char, 1, _rl_output_character_function); else for (i = _rl_last_c_pos; i < new; i++) putc (data[i], rl_outstream); #else for (i = _rl_last_c_pos; i < new; i++) putc (data[i], rl_outstream); #endif /* HACK_TERMCAP_MOTION */ } else if (_rl_last_c_pos != new) backspace (_rl_last_c_pos - new); _rl_last_c_pos = new; } /* PWP: move the cursor up or down. */ void _rl_move_vert (to) int to; { register int delta, i; if (_rl_last_v_pos == to || to > screenheight) return; #if defined (__GO32__) { int row, col; ScreenGetCursor (&row, &col); ScreenSetCursor ((row + to - _rl_last_v_pos), col); } #else /* !__GO32__ */ if ((delta = to - _rl_last_v_pos) > 0) { for (i = 0; i < delta; i++) putc ('\n', rl_outstream); tputs (term_cr, 1, _rl_output_character_function); _rl_last_c_pos = 0; } else { /* delta < 0 */ if (term_up && *term_up) for (i = 0; i < -delta; i++) tputs (term_up, 1, _rl_output_character_function); } #endif /* !__GO32__ */ _rl_last_v_pos = to; /* Now TO is here */ } /* Physically print C on rl_outstream. This is for functions which know how to optimize the display. Return the number of characters output. */ rl_show_char (c) int c; { int n = 1; if (META_CHAR (c) && (_rl_output_meta_chars == 0)) { fprintf (rl_outstream, "M-"); n += 2; c = UNMETA (c); } #if defined (DISPLAY_TABS) if (c < 32 && c != '\t') #else if (c < 32) #endif /* !DISPLAY_TABS */ { fprintf (rl_outstream, "C-"); n += 2; c += 64; } putc (c, rl_outstream); fflush (rl_outstream); return n; } int rl_character_len (c, pos) register int c, pos; { unsigned char uc; uc = (unsigned char)c; if (META_CHAR (uc)) return ((_rl_output_meta_chars == 0) ? 4 : 1); if (uc == '\t') { #if defined (DISPLAY_TABS) return (((pos | 7) + 1) - pos); #else return (2); #endif /* !DISPLAY_TABS */ } return ((isprint (uc)) ? 1 : 2); } /* How to print things in the "echo-area". The prompt is treated as a mini-modeline. */ #if defined (HAVE_VARARGS_H) rl_message (va_alist) va_dcl { char *format; va_list args; va_start (args); format = va_arg (args, char *); vsprintf (msg_buf, format, args); va_end (args); rl_display_prompt = msg_buf; rl_redisplay (); return 0; } #else /* !HAVE_VARARGS_H */ rl_message (format, arg1, arg2) char *format; { sprintf (msg_buf, format, arg1, arg2); rl_display_prompt = msg_buf; rl_redisplay (); return 0; } #endif /* !HAVE_VARARGS_H */ /* How to clear things from the "echo-area". */ rl_clear_message () { rl_display_prompt = rl_prompt; rl_redisplay (); return 0; } rl_reset_line_state () { rl_on_new_line (); rl_display_prompt = rl_prompt ? rl_prompt : ""; forced_display = 1; return 0; } /* Quick redisplay hack when erasing characters at the end of the line. */ void _rl_erase_at_end_of_line (l) int l; { register int i; backspace (l); for (i = 0; i < l; i++) putc (' ', rl_outstream); backspace (l); for (i = 0; i < l; i++) visible_line[--_rl_last_c_pos] = '\0'; rl_display_fixed++; } /* Clear to the end of the line. COUNT is the minimum number of character spaces to clear, */ static void clear_to_eol (count) int count; { #if !defined (__GO32__) if (term_clreol) { tputs (term_clreol, 1, _rl_output_character_function); } else #endif /* !__GO32__ */ space_to_eol (count); } /* Clear to the end of the line using spaces. COUNT is the minimum number of character spaces to clear, */ static void space_to_eol (count) int count; { register int i; for (i = 0; i < count; i++) putc (' ', rl_outstream); _rl_last_c_pos += count; } /* Insert COUNT characters from STRING to the output stream. */ static void insert_some_chars (string, count) char *string; int count; { #if defined (__GO32__) int row, col, width; char *row_start; ScreenGetCursor (&row, &col); width = ScreenCols (); row_start = ScreenPrimary + (row * width); memcpy (row_start + col + count, row_start + col, width - col - count); /* Place the text on the screen. */ _rl_output_some_chars (string, count); #else /* !_GO32 */ /* If IC is defined, then we do not have to "enter" insert mode. */ if (term_IC) { char *tgoto (), *buffer; buffer = tgoto (term_IC, 0, count); tputs (buffer, 1, _rl_output_character_function); _rl_output_some_chars (string, count); } else { register int i; /* If we have to turn on insert-mode, then do so. */ if (term_im && *term_im) tputs (term_im, 1, _rl_output_character_function); /* If there is a special command for inserting characters, then use that first to open up the space. */ if (term_ic && *term_ic) { for (i = count; i--; ) tputs (term_ic, 1, _rl_output_character_function); } /* Print the text. */ _rl_output_some_chars (string, count); /* If there is a string to turn off insert mode, we had best use it now. */ if (term_ei && *term_ei) tputs (term_ei, 1, _rl_output_character_function); } #endif /* !__GO32__ */ } /* Delete COUNT characters from the display line. */ static void delete_chars (count) int count; { #if defined (__GO32__) int row, col, width; char *row_start; ScreenGetCursor (&row, &col); width = ScreenCols (); row_start = ScreenPrimary + (row * width); memcpy (row_start + col, row_start + col + count, width - col - count); memset (row_start + width - count, 0, count * 2); #else /* !_GO32 */ if (count > screenwidth) /* XXX */ return; if (term_DC && *term_DC) { char *tgoto (), *buffer; buffer = tgoto (term_DC, count, count); tputs (buffer, count, _rl_output_character_function); } else { if (term_dc && *term_dc) while (count--) tputs (term_dc, 1, _rl_output_character_function); } #endif /* !__GO32__ */ } void _rl_update_final () { int full_lines; full_lines = 0; if (_rl_vis_botlin && visible_line[screenwidth * _rl_vis_botlin] == 0) { _rl_vis_botlin--; full_lines = 1; } _rl_move_vert (_rl_vis_botlin); if (full_lines && term_xn) { /* Remove final line-wrap flag in xterm. */ char *last_line; last_line = &visible_line[screenwidth * _rl_vis_botlin]; _rl_move_cursor_relative (screenwidth - 1, last_line); clear_to_eol (0); putc (last_line[screenwidth - 1], rl_outstream); } _rl_vis_botlin = 0; crlf (); fflush (rl_outstream); rl_display_fixed++; } lafe/readline/complete.c100644 325 24 112626 6106101044 13516 0ustar dlduser/* complete.c -- filename completion for readline. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #if !defined (NO_SYS_FILE) # include #endif /* !NO_SYS_FILE */ #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include #if defined (USG) && !defined (HAVE_GETPW_DECLS) extern struct passwd *getpwent (); #endif /* USG && !HAVE_GETPW_DECLS */ /* ISC systems don't define getpwent() if _POSIX_SOURCE is defined. */ #if defined (isc386) && defined (_POSIX_SOURCE) # if defined (__STDC__) extern struct passwd *getpwent (void); # else extern struct passwd *getpwent (); # endif /* !__STDC__ */ #endif /* isc386 && _POSIX_SOURCE */ #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" /* Some standard library routines. */ #include "readline.h" /* Possible values for do_replace in rl_complete_internal. */ #define NO_MATCH 0 #define SINGLE_MATCH 1 #define MULT_MATCH 2 #if !defined (strchr) && !defined (__STDC__) extern char *strchr (), *strrchr (); #endif /* !strchr && !__STDC__ */ extern char *tilde_expand (); extern char *rl_copy_text (); extern Function *rl_last_func; extern int rl_editing_mode; extern int screenwidth; /* Forward declarations for functions defined and used in this file. */ char *filename_completion_function (); char **completion_matches (); static int compare_strings (); static char *rl_strpbrk (); #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* If non-zero, then this is the address of a function to call when completing on a directory name. The function is called with the address of a string (the current directory name) as an arg. */ Function *rl_directory_completion_hook = (Function *)NULL; /* Non-zero means readline completion functions perform tilde expansion. */ int rl_complete_with_tilde_expansion = 0; /* If non-zero, non-unique completions always show the list of matches. */ int _rl_complete_show_all = 0; #if defined (VISIBLE_STATS) # if !defined (X_OK) # define X_OK 1 # endif static int stat_char (); /* Non-zero means add an additional character to each filename displayed during listing completion iff rl_filename_completion_desired which helps to indicate the type of file being listed. */ int rl_visible_stats = 0; #endif /* VISIBLE_STATS */ /* **************************************************************** */ /* */ /* Completion matching, from readline's point of view. */ /* */ /* **************************************************************** */ /* Pointer to the generator function for completion_matches (). NULL means to use filename_entry_function (), the default filename completer. */ Function *rl_completion_entry_function = (Function *)NULL; /* Pointer to alternative function to create matches. Function is called with TEXT, START, and END. START and END are indices in RL_LINE_BUFFER saying what the boundaries of TEXT are. If this function exists and returns NULL then call the value of rl_completion_entry_function to try to match, otherwise use the array of strings returned. */ CPPFunction *rl_attempted_completion_function = (CPPFunction *)NULL; /* Non-zero means to suppress normal filename completion after the user-specified completion function has been called. */ int rl_attempted_completion_over = 0; /* Local variable states what happened during the last completion attempt. */ static int completion_changed_buffer = 0; /* Complete the word at or before point. You have supplied the function that does the initial simple matching selection algorithm (see completion_matches ()). The default is to do filename completion. */ rl_complete (ignore, invoking_key) int ignore, invoking_key; { if (rl_last_func == rl_complete && !completion_changed_buffer) return (rl_complete_internal ('?')); else if (_rl_complete_show_all) return (rl_complete_internal ('!')); else return (rl_complete_internal (TAB)); } /* List the possible completions. See description of rl_complete (). */ rl_possible_completions (ignore, invoking_key) int ignore, invoking_key; { return (rl_complete_internal ('?')); } rl_insert_completions (ignore, invoking_key) int ignore, invoking_key; { return (rl_complete_internal ('*')); } /* The user must press "y" or "n". Non-zero return means "y" pressed. */ get_y_or_n () { int c; for (;;) { c = rl_read_key (); if (c == 'y' || c == 'Y' || c == ' ') return (1); if (c == 'n' || c == 'N' || c == RUBOUT) return (0); if (c == ABORT_CHAR) rl_abort (); ding (); } } /* Up to this many items will be displayed in response to a possible-completions call. After that, we ask the user if she is sure she wants to see them all. */ int rl_completion_query_items = 100; /* The basic list of characters that signal a break between words for the completer routine. The contents of this variable is what breaks words in the shell, i.e. " \t\n\"\\'`@$><=" */ char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* The list of characters that signal a break between words for rl_complete_internal. The default list is the contents of rl_basic_word_break_characters. */ char *rl_completer_word_break_characters = (char *)NULL; /* List of characters which can be used to quote a substring of the line. Completion occurs on the entire substring, and within the substring rl_completer_word_break_characters are treated as any other character, unless they also appear within this list. */ char *rl_completer_quote_characters = (char *)NULL; /* List of characters that are word break characters, but should be left in TEXT when it is passed to the completion function. The shell uses this to help determine what kind of completing to do. */ char *rl_special_prefixes = (char *)NULL; /* If non-zero, then disallow duplicates in the matches. */ int rl_ignore_completion_duplicates = 1; /* Non-zero means that the results of the matches are to be treated as filenames. This is ALWAYS zero on entry, and can only be changed within a completion entry finder function. */ int rl_filename_completion_desired = 0; /* Non-zero means that the results of the matches are to be quoted using double quotes (or an application-specific quoting mechanism) if the filename contains any characters in rl_word_break_chars. This is ALWAYS non-zero on entry, and can only be changed within a completion entry finder function. */ int rl_filename_quoting_desired = 1; /* This function, if defined, is called by the completer when real filename completion is done, after all the matching names have been generated. It is passed a (char**) known as matches in the code below. It consists of a NULL-terminated array of pointers to potential matching strings. The 1st element (matches[0]) is the maximal substring that is common to all matches. This function can re-arrange the list of matches as required, but all elements of the array must be free()'d if they are deleted. The main intent of this function is to implement FIGNORE a la SunOS csh. */ Function *rl_ignore_some_completions_function = (Function *)NULL; #if defined (SHELL) /* A function to strip quotes that are not protected by backquotes. It allows single quotes to appear within double quotes, and vice versa. It should be smarter. It's fairly shell-specific, hence the SHELL definition wrapper. */ static char * _delete_quotes (text) char *text; { char *ret, *p, *r; int l, quoted; l = strlen (text); ret = xmalloc (l + 1); for (quoted = 0, p = text, r = ret; p && *p; p++) { /* Allow backslash-quoted characters to pass through unscathed. */ if (*p == '\\') continue; /* Close quote. */ if (quoted && *p == quoted) { quoted = 0; continue; } /* Open quote. */ if (quoted == 0 && (*p == '\'' || *p == '"')) { quoted = *p; continue; } *r++ = *p; } *r = '\0'; return ret; } #endif /* SHELL */ /* Return the portion of PATHNAME that should be output when listing possible completions. If we are hacking filename completion, we are only interested in the basename, the portion following the final slash. Otherwise, we return what we were passed. */ static char * printable_part (pathname) char *pathname; { char *temp = (char *)NULL; if (rl_filename_completion_desired) temp = strrchr (pathname, '/'); if (!temp) return (pathname); else return (++temp); } /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we are using it, check for and output a single character for `special' filenames. Return 1 if we printed an extension character, 0 if not. */ static int print_filename (to_print, full_pathname) char *to_print, *full_pathname; { #if !defined (VISIBLE_STATS) fputs (to_print, rl_outstream); return 0; #else char *s, c, *new_full_pathname; int extension_char = 0, slen, tlen; fputs (to_print, rl_outstream); if (rl_filename_completion_desired && rl_visible_stats) { /* If to_print != full_pathname, to_print is the basename of the path passed. In this case, we try to expand the directory name before checking for the stat character. */ if (to_print != full_pathname) { /* Terminate the directory name. */ c = to_print[-1]; to_print[-1] = '\0'; s = tilde_expand (full_pathname); if (rl_directory_completion_hook) (*rl_directory_completion_hook) (&s); slen = strlen (s); tlen = strlen (to_print); new_full_pathname = xmalloc (slen + tlen + 2); strcpy (new_full_pathname, s); new_full_pathname[slen] = '/'; strcpy (new_full_pathname + slen + 1, to_print); extension_char = stat_char (new_full_pathname); free (new_full_pathname); to_print[-1] = c; } else { s = tilde_expand (full_pathname); extension_char = stat_char (s); } free (s); if (extension_char) putc (extension_char, rl_outstream); return (extension_char != 0); } else return 0; #endif /* VISIBLE_STATS */ } /* Complete the word at or before point. WHAT_TO_DO says what to do with the completion. `?' means list the possible completions. TAB means do standard completion. `*' means insert all of the possible completions. `!' means to do standard completion, and list all possible completions if there is more than one. */ rl_complete_internal (what_to_do) int what_to_do; { char **matches; Function *our_func; int start, scan, end, delimiter = 0, pass_next; char *text, *saved_line_buffer; char *replacement; char quote_char = '\0'; int found_quote = 0; if (rl_line_buffer) saved_line_buffer = savestring (rl_line_buffer); else saved_line_buffer = (char *)NULL; if (rl_completion_entry_function) our_func = rl_completion_entry_function; else our_func = (Function *)filename_completion_function; /* Only the completion entry function can change these. */ rl_filename_completion_desired = 0; rl_filename_quoting_desired = 1; /* We now look backwards for the start of a filename/variable word. */ end = rl_point; if (rl_point) { if (rl_completer_quote_characters) { /* We have a list of characters which can be used in pairs to quote substrings for the completer. Try to find the start of an unclosed quoted substring. */ /* FOUND_QUOTE is set so we know what kind of quotes we found. */ for (scan = pass_next = 0; scan < end; scan++) { if (pass_next) { pass_next = 0; continue; } if (rl_line_buffer[scan] == '\\') { pass_next = 1; found_quote |= 4; continue; } if (quote_char != '\0') { /* Ignore everything until the matching close quote char. */ if (rl_line_buffer[scan] == quote_char) { /* Found matching close. Abandon this substring. */ quote_char = '\0'; rl_point = end; } } else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan])) { /* Found start of a quoted substring. */ quote_char = rl_line_buffer[scan]; rl_point = scan + 1; /* Shell-like quoting conventions. */ if (quote_char == '\'') found_quote |= 1; else if (quote_char == '"') found_quote |= 2; } } } if (rl_point == end) { int quoted = 0; /* We didn't find an unclosed quoted substring upon which to do completion, so use the word break characters to find the substring on which to complete. */ while (--rl_point) { scan = rl_line_buffer[rl_point]; if (strchr (rl_completer_word_break_characters, scan) == 0) continue; #if defined (SHELL) /* Don't let word break characters in quoted substrings break words for the completer. */ if (found_quote && char_is_quoted (rl_line_buffer, rl_point)) continue; #endif /* SHELL */ /* Convoluted code, but it avoids an n^2 algorithm with calls to char_is_quoted. */ break; } } /* If we are at an unquoted word break, then advance past it. */ scan = rl_line_buffer[rl_point]; #if defined (SHELL) if ((found_quote == 0 || char_is_quoted (rl_line_buffer, rl_point) == 0) && strchr (rl_completer_word_break_characters, scan)) #else if (strchr (rl_completer_word_break_characters, scan)) #endif { /* If the character that caused the word break was a quoting character, then remember it as the delimiter. */ if (strchr ("\"'", scan) && (end - rl_point) > 1) delimiter = scan; /* If the character isn't needed to determine something special about what kind of completion to perform, then advance past it. */ if (!rl_special_prefixes || strchr (rl_special_prefixes, scan) == 0) rl_point++; } } /* At this point, we know we have an open quote if quote_char != '\0'. */ start = rl_point; rl_point = end; text = rl_copy_text (start, end); /* If the user wants to TRY to complete, but then wants to give up and use the default completion function, they set the variable rl_attempted_completion_function. */ if (rl_attempted_completion_function) { matches = (*rl_attempted_completion_function) (text, start, end); if (matches || rl_attempted_completion_over) { rl_attempted_completion_over = 0; our_func = (Function *)NULL; goto after_usual_completion; } } #if defined (SHELL) /* Beware -- we're stripping the quotes here. Do this only if we know we are doing filename completion. */ if (found_quote && our_func == (Function *)filename_completion_function) { /* delete single and double quotes */ replacement = _delete_quotes (text); free (text); text = replacement; replacement = (char *)0; } #endif /* SHELL */ matches = completion_matches (text, our_func); after_usual_completion: free (text); if (!matches) ding (); else { register int i; int should_quote; /* It seems to me that in all the cases we handle we would like to ignore duplicate possiblilities. Scan for the text to insert being identical to the other completions. */ if (rl_ignore_completion_duplicates) { char *lowest_common; int j, newlen = 0; char dead_slot; char **temp_array; /* Sort the items. */ /* It is safe to sort this array, because the lowest common denominator found in matches[0] will remain in place. */ for (i = 0; matches[i]; i++); qsort (matches, i, sizeof (char *), compare_strings); /* Remember the lowest common denominator for it may be unique. */ lowest_common = savestring (matches[0]); for (i = 0; matches[i + 1]; i++) { if (strcmp (matches[i], matches[i + 1]) == 0) { free (matches[i]); matches[i] = (char *)&dead_slot; } else newlen++; } /* We have marked all the dead slots with (char *)&dead_slot. Copy all the non-dead entries into a new array. */ temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *)); for (i = j = 1; matches[i]; i++) { if (matches[i] != (char *)&dead_slot) temp_array[j++] = matches[i]; } temp_array[j] = (char *)NULL; if (matches[0] != (char *)&dead_slot) free (matches[0]); free (matches); matches = temp_array; /* Place the lowest common denominator back in [0]. */ matches[0] = lowest_common; /* If there is one string left, and it is identical to the lowest common denominator, then the LCD is the string to insert. */ if (j == 2 && strcmp (matches[0], matches[1]) == 0) { free (matches[1]); matches[1] = (char *)NULL; } } switch (what_to_do) { case TAB: case '!': /* If we are matching filenames, then here is our chance to do clever processing by re-examining the list. Call the ignore function with the array as a parameter. It can munge the array, deleting matches as it desires. */ if (rl_ignore_some_completions_function && our_func == (Function *)filename_completion_function) (void)(*rl_ignore_some_completions_function)(matches); /* If we are doing completion on quoted substrings, and any matches contain any of the completer_word_break_characters, then auto- matically prepend the substring with a quote character (just pick the first one from the list of such) if it does not already begin with a quote string. FIXME: Need to remove any such automatically inserted quote character when it no longer is necessary, such as if we change the string we are completing on and the new set of matches don't require a quoted substring. */ replacement = matches[0]; should_quote = matches[0] && rl_completer_quote_characters && rl_filename_completion_desired && rl_filename_quoting_desired; if (should_quote) #if defined (SHELL) should_quote = should_quote && (!quote_char || quote_char == '"'); #else should_quote = should_quote && !quote_char; #endif if (should_quote) { int do_replace; do_replace = NO_MATCH; /* If there is a single match, see if we need to quote it. This also checks whether the common prefix of several matches needs to be quoted. If the common prefix should not be checked, add !matches[1] to the if clause. */ should_quote = rl_strpbrk (matches[0], rl_completer_word_break_characters) != 0; #if defined (SHELL) should_quote = should_quote || rl_strpbrk (matches[0], "#$`") != 0; #endif if (should_quote) do_replace = matches[1] ? MULT_MATCH : SINGLE_MATCH; if (do_replace != NO_MATCH) { #if defined (SHELL) /* Quote the replacement, since we found an embedded word break character in a potential match. */ char *rtext, *mtext; int rlen; extern char *double_quote (); /* in builtins/common.c */ /* If DO_REPLACE == MULT_MATCH, it means that there is more than one match. In this case, we do not add the closing quote or attempt to perform tilde expansion. If DO_REPLACE == SINGLE_MATCH, we try to perform tilde expansion, because double quotes inhibit tilde expansion by the shell. */ mtext = matches[0]; if (mtext[0] == '~' && do_replace == SINGLE_MATCH) mtext = tilde_expand (matches[0]); rtext = double_quote (mtext); if (mtext != matches[0]) free (mtext); rlen = strlen (rtext); replacement = xmalloc (rlen + 1); /* If we're completing on a quoted string where the user has already supplied the opening quote, we don't want the quote in the replacement text, and we reset QUOTE_CHAR to 0 to avoid an extra closing quote. */ if (quote_char == '"') { strcpy (replacement, rtext + 1); rlen--; quote_char = 0; } else strcpy (replacement, rtext); if (do_replace == MULT_MATCH) replacement[rlen - 1] = '\0'; free (rtext); #else /* !SHELL */ /* Found an embedded word break character in a potential match, so we need to prepend a quote character if we are replacing the completion string. */ replacement = xmalloc (strlen (matches[0]) + 2); quote_char = *rl_completer_quote_characters; *replacement = quote_char; strcpy (replacement + 1, matches[0]); #endif /* SHELL */ } } if (replacement) { rl_begin_undo_group (); rl_delete_text (start, rl_point); rl_point = start; rl_insert_text (replacement); rl_end_undo_group (); if (replacement != matches[0]) free (replacement); } /* If there are more matches, ring the bell to indicate. If this was the only match, and we are hacking files, check the file to see if it was a directory. If so, add a '/' to the name. If not, and we are at the end of the line, then add a space. */ if (matches[1]) { if (what_to_do == '!') goto display_matches; /* XXX */ else if (rl_editing_mode != vi_mode) ding (); /* There are other matches remaining. */ } else { char temp_string[4]; int temp_string_index = 0; if (quote_char) temp_string[temp_string_index++] = quote_char; temp_string[temp_string_index++] = delimiter ? delimiter : ' '; temp_string[temp_string_index++] = '\0'; if (rl_filename_completion_desired) { struct stat finfo; char *filename = tilde_expand (matches[0]); if ((stat (filename, &finfo) == 0) && S_ISDIR (finfo.st_mode)) { if (rl_line_buffer[rl_point] != '/') rl_insert_text ("/"); } else { if (rl_point == rl_end) rl_insert_text (temp_string); } free (filename); } else { if (rl_point == rl_end) rl_insert_text (temp_string); } } break; case '*': { int i = 1; rl_begin_undo_group (); rl_delete_text (start, rl_point); rl_point = start; if (matches[1]) { while (matches[i]) { rl_insert_text (matches[i++]); rl_insert_text (" "); } } else { rl_insert_text (matches[0]); rl_insert_text (" "); } rl_end_undo_group (); } break; case '?': { int len, count, limit, max; int j, k, l; /* Handle simple case first. What if there is only one answer? */ if (!matches[1]) { char *temp; temp = printable_part (matches[0]); crlf (); print_filename (temp, matches[0]); crlf (); goto restart; } /* There is more than one answer. Find out how many there are, and find out what the maximum printed length of a single entry is. */ display_matches: for (max = 0, i = 1; matches[i]; i++) { char *temp; int name_length; temp = printable_part (matches[i]); name_length = strlen (temp); if (name_length > max) max = name_length; } len = i - 1; /* If there are many items, then ask the user if she really wants to see them all. */ if (len >= rl_completion_query_items) { crlf (); fprintf (rl_outstream, "There are %d possibilities. Do you really", len); crlf (); fprintf (rl_outstream, "wish to see them all? (y or n)"); fflush (rl_outstream); if (!get_y_or_n ()) { crlf (); goto restart; } } /* How many items of MAX length can we fit in the screen window? */ max += 2; limit = screenwidth / max; if (limit != 1 && (limit * max == screenwidth)) limit--; /* Avoid a possible floating exception. If max > screenwidth, limit will be 0 and a divide-by-zero fault will result. */ if (limit == 0) limit = 1; /* How many iterations of the printing loop? */ count = (len + (limit - 1)) / limit; /* Watch out for special case. If LEN is less than LIMIT, then just do the inner printing loop. */ if (len < limit) count = 1; /* Sort the items if they are not already sorted. */ if (!rl_ignore_completion_duplicates) qsort (matches, len, sizeof (char *), compare_strings); /* Print the sorted items, up-and-down alphabetically, like ls might. */ crlf (); for (i = 1; i < count + 1; i++) { for (j = 0, l = i; j < limit; j++) { if (l > len || !matches[l]) break; else { char *temp; int printed_length; temp = printable_part (matches[l]); printed_length = strlen (temp); printed_length += print_filename (temp, matches[l]); if (j + 1 < limit) { for (k = 0; k < max - printed_length; k++) putc (' ', rl_outstream); } } l += count; } crlf (); } restart: rl_on_new_line (); } break; default: fprintf (stderr, "\r\nreadline: bad value for what_to_do in rl_complete\n"); abort (); } for (i = 0; matches[i]; i++) free (matches[i]); free (matches); } /* Check to see if the line has changed through all of this manipulation. */ if (saved_line_buffer) { if (strcmp (rl_line_buffer, saved_line_buffer) != 0) completion_changed_buffer = 1; else completion_changed_buffer = 0; free (saved_line_buffer); } return 0; } #if defined (VISIBLE_STATS) /* Return the character which best describes FILENAME. `@' for symbolic links `/' for directories `*' for executables `=' for sockets */ static int stat_char (filename) char *filename; { struct stat finfo; int character, r; #if defined (S_ISLNK) r = lstat (filename, &finfo); #else r = stat (filename, &finfo); #endif if (r == -1) return (0); character = 0; if (S_ISDIR (finfo.st_mode)) character = '/'; #if defined (S_ISLNK) else if (S_ISLNK (finfo.st_mode)) character = '@'; #endif /* S_ISLNK */ #if defined (S_ISSOCK) else if (S_ISSOCK (finfo.st_mode)) character = '='; #endif /* S_ISSOCK */ else if (S_ISREG (finfo.st_mode)) { if (access (filename, X_OK) == 0) character = '*'; } return (character); } #endif /* VISIBLE_STATS */ /* Stupid comparison routine for qsort () ing strings. */ static int compare_strings (s1, s2) char **s1, **s2; { int result; result = **s1 - **s2; if (result == 0) result = strcmp (*s1, *s2); return result; } /* A completion function for usernames. TEXT contains a partial username preceded by a random character (usually `~'). */ char * username_completion_function (text, state) int state; char *text; { #if defined (__GO32__) return (char *)NULL; #else /* !__GO32__ */ static char *username = (char *)NULL; static struct passwd *entry; static int namelen, first_char, first_char_loc; if (!state) { if (username) free (username); first_char = *text; if (first_char == '~') first_char_loc = 1; else first_char_loc = 0; username = savestring (&text[first_char_loc]); namelen = strlen (username); setpwent (); } while (entry = getpwent ()) { if ((username[0] == entry->pw_name[0]) && (strncmp (username, entry->pw_name, namelen) == 0)) break; } if (!entry) { endpwent (); return ((char *)NULL); } else { char *value = xmalloc (2 + strlen (entry->pw_name)); *value = *text; strcpy (value + first_char_loc, entry->pw_name); if (first_char == '~') rl_filename_completion_desired = 1; return (value); } #endif /* !__GO32__ */ } /* **************************************************************** */ /* */ /* Completion */ /* */ /* **************************************************************** */ /* Non-zero means that case is not significant in completion. */ int completion_case_fold = 0; /* Return an array of (char *) which is a list of completions for TEXT. If there are no completions, return a NULL pointer. The first entry in the returned array is the substitution for TEXT. The remaining entries are the possible completions. The array is terminated with a NULL pointer. ENTRY_FUNCTION is a function of two args, and returns a (char *). The first argument is TEXT. The second is a state argument; it should be zero on the first call, and non-zero on subsequent calls. It returns a NULL pointer to the caller when there are no more matches. */ char ** completion_matches (text, entry_function) char *text; CPFunction *entry_function; { /* Number of slots in match_list. */ int match_list_size; /* The list of matches. */ char **match_list = (char **)xmalloc (((match_list_size = 10) + 1) * sizeof (char *)); /* Number of matches actually found. */ int matches = 0; /* Temporary string binder. */ char *string; match_list[1] = (char *)NULL; while (string = (*entry_function) (text, matches)) { if (matches + 1 == match_list_size) match_list = (char **)xrealloc (match_list, ((match_list_size += 10) + 1) * sizeof (char *)); match_list[++matches] = string; match_list[matches + 1] = (char *)NULL; } /* If there were any matches, then look through them finding out the lowest common denominator. That then becomes match_list[0]. */ if (matches) { register int i = 1; int low = 100000; /* Count of max-matched characters. */ /* If only one match, just use that. */ if (matches == 1) { match_list[0] = match_list[1]; match_list[1] = (char *)NULL; } else { /* Otherwise, compare each member of the list with the next, finding out where they stop matching. */ while (i < matches) { register int c1, c2, si; if (completion_case_fold) { for (si = 0; (c1 = to_lower(match_list[i][si])) && (c2 = to_lower(match_list[i + 1][si])); si++) if (c1 != c2) break; } else { for (si = 0; (c1 = match_list[i][si]) && (c2 = match_list[i + 1][si]); si++) if (c1 != c2) break; } if (low > si) low = si; i++; } match_list[0] = xmalloc (low + 1); strncpy (match_list[0], match_list[1], low); match_list[0][low] = '\0'; } } else /* There were no matches. */ { free (match_list); match_list = (char **)NULL; } return (match_list); } /* Okay, now we write the entry_function for filename completion. In the general case. Note that completion in the shell is a little different because of all the pathnames that must be followed when looking up the completion for a command. */ char * filename_completion_function (text, state) int state; char *text; { static DIR *directory; static char *filename = (char *)NULL; static char *dirname = (char *)NULL; static char *users_dirname = (char *)NULL; static int filename_len; struct dirent *entry = (struct dirent *)NULL; /* If we don't have any state, then do some initialization. */ if (!state) { char *temp; if (dirname) free (dirname); if (filename) free (filename); if (users_dirname) free (users_dirname); filename = savestring (text); if (!*text) text = "."; dirname = savestring (text); temp = strrchr (dirname, '/'); if (temp) { strcpy (filename, ++temp); *temp = '\0'; } else strcpy (dirname, "."); /* We aren't done yet. We also support the "~user" syntax. */ /* Save the version of the directory that the user typed. */ users_dirname = savestring (dirname); { char *temp_dirname; int replace_dirname; temp_dirname = tilde_expand (dirname); free (dirname); dirname = temp_dirname; replace_dirname = 0; if (rl_directory_completion_hook) replace_dirname = (*rl_directory_completion_hook) (&dirname); if (replace_dirname) { free (users_dirname); users_dirname = savestring (dirname); } } directory = opendir (dirname); filename_len = strlen (filename); rl_filename_completion_desired = 1; } /* At this point we should entertain the possibility of hacking wildcarded filenames, like /usr/man/man/te. If the directory name contains globbing characters, then build an array of directories, and then map over that list while completing. */ /* *** UNIMPLEMENTED *** */ /* Now that we have some state, we can read the directory. */ while (directory && (entry = readdir (directory))) { /* Special case for no filename. All entries except "." and ".." match. */ if (!filename_len) { if ((strcmp (entry->d_name, ".") != 0) && (strcmp (entry->d_name, "..") != 0)) break; } else { /* Otherwise, if these match up to the length of filename, then it is a match. */ if ((entry->d_name[0] == filename[0]) && (((int)D_NAMLEN (entry)) >= filename_len) && (strncmp (filename, entry->d_name, filename_len) == 0)) break; } } if (!entry) { if (directory) { closedir (directory); directory = (DIR *)NULL; } if (dirname) { free (dirname); dirname = (char *)NULL; } if (filename) { free (filename); filename = (char *)NULL; } if (users_dirname) { free (users_dirname); users_dirname = (char *)NULL; } return (char *)NULL; } else { char *temp; /* dirname && (strcmp (dirname, ".") != 0) */ if (dirname && (dirname[0] != '.' || dirname[1])) { if (rl_complete_with_tilde_expansion && *users_dirname == '~') { int dirlen = strlen (dirname); temp = xmalloc (2 + dirlen + D_NAMLEN (entry)); strcpy (temp, dirname); /* Canonicalization cuts off any final slash present. We need to add it back. */ if (dirname[dirlen - 1] != '/') { temp[dirlen] = '/'; temp[dirlen + 1] = '\0'; } } else { temp = xmalloc (1 + strlen (users_dirname) + D_NAMLEN (entry)); strcpy (temp, users_dirname); } strcat (temp, entry->d_name); } else temp = (savestring (entry->d_name)); return (temp); } } /* A function for simple tilde expansion. */ int rl_tilde_expand (ignore, key) int ignore, key; { register int start, end; char *homedir; end = rl_point; start = end - 1; if (rl_point == rl_end && rl_line_buffer[rl_point] == '~') { homedir = tilde_expand ("~"); goto insert; } else if (rl_line_buffer[start] != '~') { for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--); start++; } end = start; do { end++; } while (!whitespace (rl_line_buffer[end]) && end < rl_end); if (whitespace (rl_line_buffer[end]) || end >= rl_end) end--; /* If the first character of the current word is a tilde, perform tilde expansion and insert the result. If not a tilde, do nothing. */ if (rl_line_buffer[start] == '~') { char *temp; int len; len = end - start + 1; temp = xmalloc (len + 1); strncpy (temp, rl_line_buffer + start, len); temp[len] = '\0'; homedir = tilde_expand (temp); free (temp); insert: rl_begin_undo_group (); rl_delete_text (start, end + 1); rl_point = start; rl_insert_text (homedir); rl_end_undo_group (); } return (0); } /* Find the first occurrence in STRING1 of any character from STRING2. Return a pointer to the character in STRING1. */ static char * rl_strpbrk (string1, string2) char *string1, *string2; { register char *scan; for (; *string1; string1++) { for (scan = string2; *scan; scan++) { if (*string1 == *scan) { return (string1); } } } return ((char *)NULL); } #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ lafe/readline/chardefs.h100444 325 24 6236 6106101044 13427 0ustar dlduser/* chardefs.h -- Character definitions for readline. */ /* Copyright (C) 1994 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _CHARDEFS_H #define _CHARDEFS_H #include #include "rldefs.h" #if defined (HAVE_STRING_H) # include #else # include #endif /* HAVE_STRING_H */ #ifndef whitespace #define whitespace(c) (((c) == ' ') || ((c) == '\t')) #endif #ifdef CTRL #undef CTRL #endif /* Some character stuff. */ #define control_character_threshold 0x020 /* Smaller than this is control. */ #define control_character_mask 0x1f /* 0x20 - 1 */ #define meta_character_threshold 0x07f /* Larger than this is Meta. */ #define control_character_bit 0x40 /* 0x000000, must be off. */ #define meta_character_bit 0x080 /* x0000000, must be on. */ #define largest_char 255 /* Largest character value. */ #define CTRL_CHAR(c) ((c) < control_character_threshold) #define META_CHAR(c) ((c) > meta_character_threshold && (c) <= largest_char) #define CTRL(c) ((c) & control_character_mask) #define META(c) ((c) | meta_character_bit) #define UNMETA(c) ((c) & (~meta_character_bit)) #define UNCTRL(c) to_upper(((c)|control_character_bit)) /* Old versions #define lowercase_p(c) (((c) > ('a' - 1) && (c) < ('z' + 1))) #define uppercase_p(c) (((c) > ('A' - 1) && (c) < ('Z' + 1))) #define digit_p(c) ((c) >= '0' && (c) <= '9') */ #define lowercase_p(c) (islower(c)) #define uppercase_p(c) (isupper(c)) #define digit_p(x) (isdigit (x)) #define pure_alphabetic(c) (lowercase_p(c) || uppercase_p(c)) /* Old versions # define to_upper(c) (lowercase_p(c) ? ((c) - 32) : (c)) # define to_lower(c) (uppercase_p(c) ? ((c) + 32) : (c)) */ #ifndef to_upper # define to_upper(c) (islower(c) ? toupper(c) : (c)) # define to_lower(c) (isupper(c) ? tolower(c) : (c)) #endif #ifndef digit_value #define digit_value(x) ((x) - '0') #endif #ifndef NEWLINE #define NEWLINE '\n' #endif #ifndef RETURN #define RETURN CTRL('M') #endif #ifndef RUBOUT #define RUBOUT 0x7f #endif #ifndef TAB #define TAB '\t' #endif #ifdef ABORT_CHAR #undef ABORT_CHAR #endif #define ABORT_CHAR CTRL('G') #ifdef PAGE #undef PAGE #endif #define PAGE CTRL('L') #ifdef SPACE #undef SPACE #endif #define SPACE ' ' /* XXX - was 0x20 */ #ifdef ESC #undef ESC #endif #define ESC CTRL('[') #endif /* _CHARDEFS_H */ lafe/readline/xmalloc.c100644 325 24 4111 6106101044 13272 0ustar dlduser/* xmalloc.c -- safe versions of malloc and realloc */ /* Copyright (C) 1991 Free Software Foundation, Inc. This file is part of GNU Readline, a library for reading lines of text with interactive input and history editing. Readline is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. Readline is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Readline; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if defined (ALREADY_HAVE_XMALLOC) #else #include #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ static void memory_error_and_abort (); /* **************************************************************** */ /* */ /* Memory Allocation and Deallocation. */ /* */ /* **************************************************************** */ /* Return a pointer to free()able block of memory large enough to hold BYTES number of bytes. If the memory cannot be allocated, print an error message and abort. */ char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort ("xmalloc"); return (temp); } char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort ("xrealloc"); return (temp); } static void memory_error_and_abort (fname) char *fname; { fprintf (stderr, "%s: Out of virtual memory!\n", fname); abort (); } #endif /* !ALREADY_HAVE_XMALLOC */ lafe/readline/posixstat.h100644 325 24 10741 6106101044 13724 0ustar dlduser/* posixstat.h -- Posix stat(2) definitions for systems that don't have them. */ /* Copyright (C) 1987,1991 Free Software Foundation, Inc. This file is part of GNU Bash, the Bourne Again SHell. Bash is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. Bash is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Bash; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* This file should be included instead of . It relies on the local sys/stat.h to work though. */ #if !defined (_POSIXSTAT_H) #define _POSIXSTAT_H #include #if defined (isc386) # if !defined (S_IFDIR) # define S_IFDIR 0040000 # endif /* !S_IFDIR */ # if !defined (S_IFMT) # define S_IFMT 0170000 # endif /* !S_IFMT */ #endif /* isc386 */ /* This text is taken directly from the Cadmus I was trying to compile on: the following MACROs are defined for X/OPEN compatibility however, is the param correct ?? #define S_ISBLK(s) ((s.st_mode & S_IFMT) == S_IFBLK) Well, the answer is no. Thus... */ #if defined (BrainDeath) # undef S_ISBLK # undef S_ISCHR # undef S_ISDIR # undef S_ISFIFO # undef S_ISREG #endif /* BrainDeath */ /* Posix 1003.1 5.6.1.1 file types */ /* Some Posix-wannabe systems define _S_IF* macros instead of S_IF*, but do not provide the S_IS* macros that Posix requires. */ #if defined (_S_IFMT) && !defined (S_IFMT) #define S_IFMT _S_IFMT #endif #if defined (_S_IFIFO) && !defined (S_IFIFO) #define S_IFIFO _S_IFIFO #endif #if defined (_S_IFCHR) && !defined (S_IFCHR) #define S_IFCHR _S_IFCHR #endif #if defined (_S_IFDIR) && !defined (S_IFDIR) #define S_IFDIR _S_IFDIR #endif #if defined (_S_IFBLK) && !defined (S_IFBLK) #define S_IFBLK _S_IFBLK #endif #if defined (_S_IFREG) && !defined (S_IFREG) #define S_IFREG _S_IFREG #endif #if defined (_S_IFLNK) && !defined (S_IFLNK) #define S_IFLNK _S_IFLNK #endif #if defined (_S_IFSOCK) && !defined (S_IFSOCK) #define S_IFSOCK _S_IFSOCK #endif /* Test for each symbol individually and define the ones necessary (some systems claiming Posix compatibility define some but not all). */ #if defined (S_IFBLK) && !defined (S_ISBLK) #define S_ISBLK(m) (((m)&S_IFMT) == S_IFBLK) /* block device */ #endif #if defined (S_IFCHR) && !defined (S_ISCHR) #define S_ISCHR(m) (((m)&S_IFMT) == S_IFCHR) /* character device */ #endif #if defined (S_IFDIR) && !defined (S_ISDIR) #define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR) /* directory */ #endif #if defined (S_IFREG) && !defined (S_ISREG) #define S_ISREG(m) (((m)&S_IFMT) == S_IFREG) /* file */ #endif #if defined (S_IFIFO) && !defined (S_ISFIFO) #define S_ISFIFO(m) (((m)&S_IFMT) == S_IFIFO) /* fifo - named pipe */ #endif #if defined (S_IFLNK) && !defined (S_ISLNK) #define S_ISLNK(m) (((m)&S_IFMT) == S_IFLNK) /* symbolic link */ #endif #if defined (S_IFSOCK) && !defined (S_ISSOCK) #define S_ISSOCK(m) (((m)&S_IFMT) == S_IFSOCK) /* socket */ #endif /* * POSIX 1003.1 5.6.1.2 File Modes */ #if !defined (S_IRWXU) # if !defined (S_IREAD) # define S_IREAD 00400 # define S_IWRITE 00200 # define S_IEXEC 00100 # endif /* S_IREAD */ # if !defined (S_IRUSR) # define S_IRUSR S_IREAD /* read, owner */ # define S_IWUSR S_IWRITE /* write, owner */ # define S_IXUSR S_IEXEC /* execute, owner */ # define S_IRGRP (S_IREAD >> 3) /* read, group */ # define S_IWGRP (S_IWRITE >> 3) /* write, group */ # define S_IXGRP (S_IEXEC >> 3) /* execute, group */ # define S_IROTH (S_IREAD >> 6) /* read, other */ # define S_IWOTH (S_IWRITE >> 6) /* write, other */ # define S_IXOTH (S_IEXEC >> 6) /* execute, other */ # endif /* !S_IRUSR */ # define S_IRWXU (S_IRUSR | S_IWUSR | S_IXUSR) # define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP) # define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH) #endif /* !S_IRWXU */ /* These are non-standard, but are used in builtins.c$symbolic_umask() */ #define S_IRUGO (S_IRUSR | S_IRGRP | S_IROTH) #define S_IWUGO (S_IWUSR | S_IWGRP | S_IWOTH) #define S_IXUGO (S_IXUSR | S_IXGRP | S_IXOTH) #endif /* _POSIXSTAT_H */ lafe/readline/tilde.h100644 325 24 2627 6106101044 12753 0ustar dlduser/* tilde.h: Externally available variables and function in libtilde.a. */ #if !defined (__TILDE_H__) # define __TILDE_H__ /* Function pointers can be declared as (Function *)foo. */ #if !defined (__FUNCTION_DEF) # define __FUNCTION_DEF typedef int Function (); typedef void VFunction (); typedef char *CPFunction (); typedef char **CPPFunction (); #endif /* _FUNCTION_DEF */ /* If non-null, this contains the address of a function to call if the standard meaning for expanding a tilde fails. The function is called with the text (sans tilde, as in "foo"), and returns a malloc()'ed string which is the expansion, or a NULL pointer if there is no expansion. */ extern CPFunction *tilde_expansion_failure_hook; /* When non-null, this is a NULL terminated array of strings which are duplicates for a tilde prefix. Bash uses this to expand `=~' and `:~'. */ extern char **tilde_additional_prefixes; /* When non-null, this is a NULL terminated array of strings which match the end of a username, instead of just "/". Bash sets this to `:' and `=~'. */ extern char **tilde_additional_suffixes; /* Return a new string which is the result of tilde expanding STRING. */ extern char *tilde_expand (); /* Do the work of tilde expansion on FILENAME. FILENAME starts with a tilde. If there is no expansion, call tilde_expansion_failure_hook. */ extern char *tilde_expand_word (); #endif /* __TILDE_H__ */ lafe/readline/tilde.c100444 325 24 22644 6106101044 12765 0ustar dlduser/* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */ /* Copyright (C) 1988,1989 Free Software Foundation, Inc. This file is part of GNU Readline, a library for reading lines of text with interactive input and history editing. Readline is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. Readline is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Readline; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "memalloc.h" #include "rldefs.h" #if defined (HAVE_STRING_H) # include #else /* !HAVE_STRING_H */ # include #endif /* !HAVE_STRING_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include "tilde.h" #include #if defined (USG) && !defined (HAVE_GETPW_DECLS) extern struct passwd *getpwuid (), *getpwnam (); #endif /* USG && !defined (HAVE_GETPW_DECLS) */ #if !defined (savestring) extern char *xmalloc (); # ifndef strcpy extern char *strcpy (); # endif #define savestring(x) strcpy (xmalloc (1 + strlen (x)), (x)) #endif /* !savestring */ #if !defined (NULL) # if defined (__STDC__) # define NULL ((void *) 0) # else # define NULL 0x0 # endif /* !__STDC__ */ #endif /* !NULL */ #if defined (TEST) || defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* TEST || STATIC_MALLOC */ /* The default value of tilde_additional_prefixes. This is set to whitespace preceding a tilde so that simple programs which do not perform any word separation get desired behaviour. */ static char *default_prefixes[] = { " ~", "\t~", (char *)NULL }; /* The default value of tilde_additional_suffixes. This is set to whitespace or newline so that simple programs which do not perform any word separation get desired behaviour. */ static char *default_suffixes[] = { " ", "\n", (char *)NULL }; /* If non-null, this contains the address of a function to call if the standard meaning for expanding a tilde fails. The function is called with the text (sans tilde, as in "foo"), and returns a malloc()'ed string which is the expansion, or a NULL pointer if there is no expansion. */ CPFunction *tilde_expansion_failure_hook = (CPFunction *)NULL; /* When non-null, this is a NULL terminated array of strings which are duplicates for a tilde prefix. Bash uses this to expand `=~' and `:~'. */ char **tilde_additional_prefixes = default_prefixes; /* When non-null, this is a NULL terminated array of strings which match the end of a username, instead of just "/". Bash sets this to `:' and `=~'. */ char **tilde_additional_suffixes = default_suffixes; /* Find the start of a tilde expansion in STRING, and return the index of the tilde which starts the expansion. Place the length of the text which identified this tilde starter in LEN, excluding the tilde itself. */ static int tilde_find_prefix (string, len) char *string; int *len; { register int i, j, string_len; register char **prefixes = tilde_additional_prefixes; string_len = strlen (string); *len = 0; if (!*string || *string == '~') return (0); if (prefixes) { for (i = 0; i < string_len; i++) { for (j = 0; prefixes[j]; j++) { if (strncmp (string + i, prefixes[j], strlen (prefixes[j])) == 0) { *len = strlen (prefixes[j]) - 1; return (i + *len); } } } } return (string_len); } /* Find the end of a tilde expansion in STRING, and return the index of the character which ends the tilde definition. */ static int tilde_find_suffix (string) char *string; { register int i, j, string_len; register char **suffixes = tilde_additional_suffixes; string_len = strlen (string); for (i = 0; i < string_len; i++) { if (string[i] == '/' || !string[i]) break; for (j = 0; suffixes && suffixes[j]; j++) { if (strncmp (string + i, suffixes[j], strlen (suffixes[j])) == 0) return (i); } } return (i); } /* Return a new string which is the result of tilde expanding STRING. */ char * tilde_expand (string) char *string; { char *result, *tilde_expand_word (); int result_size, result_index; result_size = result_index = 0; result = (char *)NULL; /* Scan through STRING expanding tildes as we come to them. */ while (1) { register int start, end; char *tilde_word, *expansion; int len; /* Make START point to the tilde which starts the expansion. */ start = tilde_find_prefix (string, &len); /* Copy the skipped text into the result. */ if ((result_index + start + 1) > result_size) result = (char *)xrealloc (result, 1 + (result_size += (start + 20))); strncpy (result + result_index, string, start); result_index += start; /* Advance STRING to the starting tilde. */ string += start; /* Make END be the index of one after the last character of the username. */ end = tilde_find_suffix (string); /* If both START and END are zero, we are all done. */ if (!start && !end) break; /* Expand the entire tilde word, and copy it into RESULT. */ tilde_word = (char *)xmalloc (1 + end); strncpy (tilde_word, string, end); tilde_word[end] = '\0'; string += end; expansion = tilde_expand_word (tilde_word); free (tilde_word); len = strlen (expansion); if ((result_index + len + 1) > result_size) result = (char *)xrealloc (result, 1 + (result_size += (len + 20))); strcpy (result + result_index, expansion); result_index += len; free (expansion); } result[result_index] = '\0'; return (result); } /* Do the work of tilde expansion on FILENAME. FILENAME starts with a tilde. If there is no expansion, call tilde_expansion_failure_hook. */ char * tilde_expand_word (filename) char *filename; { char *dirname; dirname = filename ? savestring (filename) : (char *)NULL; if (dirname && *dirname == '~') { char *temp_name; if (!dirname[1] || dirname[1] == '/') { /* Prepend $HOME to the rest of the string. */ char *temp_home = (char *)getenv ("HOME"); /* If there is no HOME variable, look up the directory in the password database. */ if (!temp_home) { struct passwd *entry; entry = getpwuid (getuid ()); if (entry) temp_home = entry->pw_dir; } temp_name = xmalloc (1 + strlen (&dirname[1]) + (temp_home ? strlen (temp_home) : 0)); temp_name[0] = '\0'; if (temp_home) strcpy (temp_name, temp_home); strcat (temp_name, dirname + 1); free (dirname); dirname = temp_name; } else { char u_name[257]; struct passwd *user_entry; char *username; int i, c; username = u_name; for (i = 1; c = dirname[i]; i++) { if (c == '/') break; else username[i - 1] = c; } username[i - 1] = '\0'; if (!(user_entry = getpwnam (username))) { /* If the calling program has a special syntax for expanding tildes, and we couldn't find a standard expansion, then let them try. */ if (tilde_expansion_failure_hook) { char *expansion; expansion = (*tilde_expansion_failure_hook) (username); if (expansion) { temp_name = xmalloc (1 + strlen (expansion) + strlen (&dirname[i])); strcpy (temp_name, expansion); strcat (temp_name, &dirname[i]); free (expansion); free (dirname); dirname = temp_name; } } /* We shouldn't report errors. */ } else { temp_name = xmalloc (1 + strlen (user_entry->pw_dir) + strlen (&dirname[i])); strcpy (temp_name, user_entry->pw_dir); strcat (temp_name, &dirname[i]); free (dirname); dirname = temp_name; } endpwent (); } } return (dirname); } #if defined (TEST) #undef NULL #include main (argc, argv) int argc; char **argv; { char *result, line[512]; int done = 0; while (!done) { printf ("~expand: "); fflush (stdout); if (!gets (line)) strcpy (line, "done"); if ((strcmp (line, "done") == 0) || (strcmp (line, "quit") == 0) || (strcmp (line, "exit") == 0)) { done = 1; break; } result = tilde_expand (line); printf (" --> %s\n", result); free (result); } exit (0); } static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } /* * Local variables: * compile-command: "gcc -g -DTEST -o tilde tilde.c" * end: */ #endif /* TEST */ lafe/readline/STANDALONE100644 325 24 2232 6106101044 13044 0ustar dlduserThis is a description of C preprocessor defines that readline accepts. Most are passed in from the parent `make'; e.g. from the bash source directory. NO_SYS_FILE is not present HAVE_UNISTD_H exists HAVE_STDLIB_H exists HAVE_VARARGS_H exists and is usable HAVE_STRING_H exists HAVE_ALLOCA_H exists and is needed for alloca() HAVE_ALLOCA alloca(3) or a define for it exists PRAGMA_ALLOCA use of alloca() requires a #pragma, as in AIX 3.x VOID_SIGHANDLER signal handlers are void functions HAVE_DIRENT_H exists and is usable HAVE_SYS_PTEM_H exists HAVE_SYS_PTE_H exists HAVE_SYS_STREAM_H exists System-specific options: GWINSZ_IN_SYS_IOCTL need to include for TIOCGWINSZ HAVE_GETPW_DECLS the getpw* functions are declared in and cannot be redeclared without compiler errors HAVE_STRCASECMP the strcasecmp and strncasecmp functions are available USG Running a variant of System V USGr3 Running System V.3 XENIX_22 Xenix 2.2 Linux Linux CRAY running a recent version of Cray UNICOS SunOS4 Running SunOS 4.x lafe/readline/funmap.c100644 325 24 21724 6106101044 13152 0ustar dlduser/* funmap.c -- attach names to functions. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ #if !defined (BUFSIZ) #include #endif /* BUFSIZ */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include "rlconf.h" #include "readline.h" static int qsort_string_compare (); FUNMAP **funmap = (FUNMAP **)NULL; static int funmap_size = 0; static int funmap_entry = 0; /* After initializing the function map, this is the index of the first program specific function. */ int funmap_program_specific_entry_start; static FUNMAP default_funmap[] = { { "abort", rl_abort }, { "accept-line", rl_newline }, { "arrow-key-prefix", rl_arrow_keys }, { "backward-char", rl_backward }, { "backward-delete-char", rl_rubout }, { "backward-kill-line", rl_backward_kill_line }, { "backward-kill-word", rl_backward_kill_word }, { "backward-word", rl_backward_word }, { "beginning-of-history", rl_beginning_of_history }, { "beginning-of-line", rl_beg_of_line }, { "call-last-kbd-macro", rl_call_last_kbd_macro }, { "capitalize-word", rl_capitalize_word }, { "clear-screen", rl_clear_screen }, { "complete", rl_complete }, { "delete-char", rl_delete }, { "delete-horizontal-space", rl_delete_horizontal_space }, { "digit-argument", rl_digit_argument }, { "do-lowercase-version", rl_do_lowercase_version }, { "downcase-word", rl_downcase_word }, { "dump-functions", rl_dump_functions }, { "emacs-editing-mode", rl_emacs_editing_mode }, { "end-kbd-macro", rl_end_kbd_macro }, { "end-of-history", rl_end_of_history }, { "end-of-line", rl_end_of_line }, { "forward-char", rl_forward }, { "forward-search-history", rl_forward_search_history }, { "forward-word", rl_forward_word }, { "history-search-backward", rl_history_search_backward }, { "history-search-forward", rl_history_search_forward }, { "insert-completions", rl_insert_completions }, { "kill-whole-line", rl_kill_full_line }, { "kill-line", rl_kill_line }, { "kill-word", rl_kill_word }, { "next-history", rl_get_next_history }, { "non-incremental-forward-search-history", rl_noninc_forward_search }, { "non-incremental-reverse-search-history", rl_noninc_reverse_search }, { "non-incremental-forward-search-history-again", rl_noninc_forward_search_again }, { "non-incremental-reverse-search-history-again", rl_noninc_reverse_search_again }, { "possible-completions", rl_possible_completions }, { "previous-history", rl_get_previous_history }, { "quoted-insert", rl_quoted_insert }, { "re-read-init-file", rl_re_read_init_file }, { "redraw-current-line", rl_refresh_line}, { "reverse-search-history", rl_reverse_search_history }, { "revert-line", rl_revert_line }, { "self-insert", rl_insert }, { "start-kbd-macro", rl_start_kbd_macro }, { "tab-insert", rl_tab_insert }, { "tilde-expand", rl_tilde_expand }, { "transpose-chars", rl_transpose_chars }, { "transpose-words", rl_transpose_words }, { "tty-status", rl_tty_status }, { "undo", rl_undo_command }, { "universal-argument", rl_universal_argument }, { "unix-line-discard", rl_unix_line_discard }, { "unix-word-rubout", rl_unix_word_rubout }, { "upcase-word", rl_upcase_word }, { "yank", rl_yank }, { "yank-last-arg", rl_yank_last_arg }, { "yank-nth-arg", rl_yank_nth_arg }, { "yank-pop", rl_yank_pop }, #if defined (VI_MODE) { "vi-append-eol", rl_vi_append_eol }, { "vi-append-mode", rl_vi_append_mode }, { "vi-arg-digit", rl_vi_arg_digit }, { "vi-bWord", rl_vi_bWord }, { "vi-bracktype", rl_vi_bracktype }, { "vi-bword", rl_vi_bword }, { "vi-change-case", rl_vi_change_case }, { "vi-change-char", rl_vi_change_char }, { "vi-change-to", rl_vi_change_to }, { "vi-char-search", rl_vi_char_search }, { "vi-column", rl_vi_column }, { "vi-comment", rl_vi_comment }, { "vi-complete", rl_vi_complete }, { "vi-delete", rl_vi_delete }, { "vi-delete-to", rl_vi_delete_to }, { "vi-eWord", rl_vi_eWord }, { "vi-editing-mode", rl_vi_editing_mode }, { "vi-end-word", rl_vi_end_word }, { "vi-eof-maybe", rl_vi_eof_maybe }, { "vi-eword", rl_vi_eword }, { "vi-fWord", rl_vi_fWord }, { "vi-first-print", rl_vi_first_print }, { "vi-fword", rl_vi_fword }, { "vi-insert-beg", rl_vi_insert_beg }, { "vi-insertion-mode", rl_vi_insertion_mode }, { "vi-match", rl_vi_match }, { "vi-movement-mode", rl_vi_movement_mode }, { "vi-next-word", rl_vi_next_word }, { "vi-overstrike", rl_vi_overstrike }, { "vi-overstrike-delete", rl_vi_overstrike_delete }, { "vi-prev-word", rl_vi_prev_word }, { "vi-put", rl_vi_put }, { "vi-redo", rl_vi_redo }, { "vi-replace", rl_vi_replace }, { "vi-search", rl_vi_search }, { "vi-search-again", rl_vi_search_again }, { "vi-subst", rl_vi_subst }, { "vi-tilde-expand", rl_vi_tilde_expand }, { "vi-yank-arg", rl_vi_yank_arg }, { "vi-yank-to", rl_vi_yank_to }, #endif /* VI_MODE */ {(char *)NULL, (Function *)NULL } }; rl_add_funmap_entry (name, function) char *name; Function *function; { if (funmap_entry + 2 >= funmap_size) if (!funmap) funmap = (FUNMAP **)xmalloc ((funmap_size = 80) * sizeof (FUNMAP *)); else funmap = (FUNMAP **)xrealloc (funmap, (funmap_size += 80) * sizeof (FUNMAP *)); funmap[funmap_entry] = (FUNMAP *)xmalloc (sizeof (FUNMAP)); funmap[funmap_entry]->name = name; funmap[funmap_entry]->function = function; funmap[++funmap_entry] = (FUNMAP *)NULL; return funmap_entry; } static int funmap_initialized = 0; /* Make the funmap contain all of the default entries. */ void rl_initialize_funmap () { register int i; if (funmap_initialized) return; for (i = 0; default_funmap[i].name; i++) rl_add_funmap_entry (default_funmap[i].name, default_funmap[i].function); funmap_initialized = 1; funmap_program_specific_entry_start = i; } /* Produce a NULL terminated array of known function names. The array is sorted. The array itself is allocated, but not the strings inside. You should free () the array when you done, but not the pointrs. */ char ** rl_funmap_names () { char **result = (char **)NULL; int result_size, result_index; result_size = result_index = 0; /* Make sure that the function map has been initialized. */ rl_initialize_funmap (); for (result_index = 0; funmap[result_index]; result_index++) { if (result_index + 2 > result_size) { if (!result) result = (char **)xmalloc ((result_size = 20) * sizeof (char *)); else result = (char **) xrealloc (result, (result_size += 20) * sizeof (char *)); } result[result_index] = funmap[result_index]->name; result[result_index + 1] = (char *)NULL; } qsort (result, result_index, sizeof (char *), qsort_string_compare); return (result); } /* Stupid comparison routine for qsort () ing strings. */ static int qsort_string_compare (s1, s2) register char **s1, **s2; { int r; r = **s1 - **s2; if (r == 0) r = strcmp (*s1, *s2); return r; } /* Things that mean `Control'. */ char *possible_control_prefixes[] = { "Control-", "C-", "CTRL-", (char *)NULL }; char *possible_meta_prefixes[] = { "Meta", "M-", (char *)NULL }; #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "history: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ lafe/readline/readline.h100644 325 24 27306 6106101044 13456 0ustar dlduser/* Readline.h -- the names of functions callable from within readline. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (_READLINE_H_) #define _READLINE_H_ #if defined (READLINE_LIBRARY) # include "keymaps.h" # include "tilde.h" #else # include # include #endif /* The functions for manipulating the text of the line within readline. Most of these functions are bound to keys by default. */ extern int rl_tilde_expand (), rl_beg_of_line (), rl_backward (), rl_delete (), rl_end_of_line (), rl_forward (), ding (), rl_backward (), rl_newline (), rl_kill_line (), rl_clear_screen (), rl_get_next_history (), rl_get_previous_history (), rl_quoted_insert (), rl_reverse_search_history (), rl_transpose_chars (), rl_unix_line_discard (), rl_quoted_insert (), rl_unix_word_rubout (), rl_yank (), rl_rubout (), rl_backward_word (), rl_kill_word (), rl_forward_word (), rl_tab_insert (), rl_yank_pop (), rl_yank_nth_arg (), rl_backward_kill_word (), rl_backward_kill_line (), rl_transpose_words (), rl_complete (), rl_possible_completions (), rl_insert_completions (), rl_do_lowercase_version (), rl_kill_full_line (), rl_digit_argument (), rl_universal_argument (), rl_abort (), rl_undo_command (), rl_revert_line (), rl_beginning_of_history (), rl_end_of_history (), rl_forward_search_history (), rl_insert (), rl_upcase_word (), rl_downcase_word (), rl_capitalize_word (), rl_restart_output (), rl_re_read_init_file (), rl_dump_functions (), rl_delete_horizontal_space (), rl_history_search_forward (), rl_history_search_backward (), rl_tty_status (), rl_yank_last_arg (); /* `Public' utility functions. */ extern int rl_insert_text (), rl_delete_text (), rl_kill_text (); extern int rl_complete_internal (); extern int rl_expand_prompt (); extern int rl_initialize (); extern int rl_set_signals (), rl_clear_signals (); extern int rl_init_argument (), rl_digit_argument (); extern int rl_read_key (), rl_getc (), rl_stuff_char (); extern int maybe_save_line (), maybe_unsave_line (), maybe_replace_line (); extern int rl_modifying (); extern int rl_begin_undo_group (), rl_end_undo_group (); extern void rl_add_undo (), free_undo_list (); extern int rl_do_undo (); /* Not available unless readline is compiled -DPAREN_MATCHING. */ extern int rl_insert_close (); /* These are *both* defined even when VI_MODE is not. */ extern int rl_vi_editing_mode (), rl_emacs_editing_mode (); /* Non incremental history searching. */ extern int rl_noninc_forward_search (), rl_noninc_reverse_search (), rl_noninc_forward_search_again (), rl_noninc_reverse_search_again (); /* Things for vi mode. Not available unless readline is compiled -DVI_MODE. */ extern int rl_vi_check (), rl_vi_textmod_command (); extern int rl_vi_redo (), rl_vi_tilde_expand (), rl_vi_movement_mode (), rl_vi_insertion_mode (), rl_vi_arg_digit (), rl_vi_prev_word (), rl_vi_next_word (), rl_vi_char_search (), rl_vi_eof_maybe (), rl_vi_append_mode (), rl_vi_put (), rl_vi_append_eol (), rl_vi_insert_beg (), rl_vi_delete (), rl_vi_comment (), rl_vi_first_print (), rl_vi_fword (), rl_vi_fWord (), rl_vi_bword (), rl_vi_bWord (), rl_vi_eword (), rl_vi_eWord (), rl_vi_end_word (), rl_vi_change_case (), rl_vi_match (), rl_vi_bracktype (), rl_vi_change_char (), rl_vi_yank_arg (), rl_vi_search (), rl_vi_search_again (), rl_vi_subst (), rl_vi_overstrike (), rl_vi_overstrike_delete (), rl_vi_replace(), rl_vi_column (), rl_vi_delete_to (), rl_vi_change_to (), rl_vi_yank_to (), rl_vi_complete (), rl_vi_fetch_history (); /* Keyboard macro commands. */ extern int rl_start_kbd_macro (), rl_end_kbd_macro (); extern int rl_call_last_kbd_macro (); extern int rl_arrow_keys(), rl_refresh_line (); /* Maintaining the state of undo. We remember individual deletes and inserts on a chain of things to do. */ /* The actions that undo knows how to undo. Notice that UNDO_DELETE means to insert some text, and UNDO_INSERT means to delete some text. I.e., the code tells undo what to undo, not how to undo it. */ enum undo_code { UNDO_DELETE, UNDO_INSERT, UNDO_BEGIN, UNDO_END }; /* What an element of THE_UNDO_LIST looks like. */ typedef struct undo_list { struct undo_list *next; int start, end; /* Where the change took place. */ char *text; /* The text to insert, if undoing a delete. */ enum undo_code what; /* Delete, Insert, Begin, End. */ } UNDO_LIST; /* The current undo list for RL_LINE_BUFFER. */ extern UNDO_LIST *rl_undo_list; /* The data structure for mapping textual names to code addresses. */ typedef struct { char *name; Function *function; } FUNMAP; extern FUNMAP **funmap; /* **************************************************************** */ /* */ /* Well Published Variables */ /* */ /* **************************************************************** */ /* The name of the calling program. You should initialize this to whatever was in argv[0]. It is used when parsing conditionals. */ extern char *rl_readline_name; /* The line buffer that is in use. */ extern char *rl_line_buffer; /* The location of point, and end. */ extern int rl_point, rl_end; /* The name of the terminal to use. */ extern char *rl_terminal_name; /* The input and output streams. */ extern FILE *rl_instream, *rl_outstream; /* The basic list of characters that signal a break between words for the completer routine. The initial contents of this variable is what breaks words in the shell, i.e. "n\"\\'`@$>". */ extern char *rl_basic_word_break_characters; /* The list of characters that signal a break between words for rl_complete_internal. The default list is the contents of rl_basic_word_break_characters. */ extern char *rl_completer_word_break_characters; /* List of characters which can be used to quote a substring of the line. Completion occurs on the entire substring, and within the substring rl_completer_word_break_characters are treated as any other character, unless they also appear within this list. */ extern char *rl_completer_quote_characters; /* List of characters that are word break characters, but should be left in TEXT when it is passed to the completion function. The shell uses this to help determine what kind of completing to do. */ extern char *rl_special_prefixes; /* Pointer to the generator function for completion_matches (). NULL means to use filename_entry_function (), the default filename completer. */ extern Function *rl_completion_entry_function; /* If rl_ignore_some_completions_function is non-NULL it is the address of a function to call after all of the possible matches have been generated, but before the actual completion is done to the input line. The function is called with one argument; a NULL terminated array of (char *). If your function removes any of the elements, they must be free()'ed. */ extern Function *rl_ignore_some_completions_function; /* Pointer to alternative function to create matches. Function is called with TEXT, START, and END. START and END are indices in RL_LINE_BUFFER saying what the boundaries of TEXT are. If this function exists and returns NULL then call the value of rl_completion_entry_function to try to match, otherwise use the array of strings returned. */ extern CPPFunction *rl_attempted_completion_function; /* If non-zero, then this is the address of a function to call just before readline_internal () prints the first prompt. */ extern Function *rl_startup_hook; /* If non-zero, then this is the address of a function to call when completing on a directory name. The function is called with the address of a string (the current directory name) as an arg. */ extern Function *rl_directory_completion_hook; /* Backwards compatibility with previous versions of readline. */ #define rl_symbolic_link_hook rl_directory_completion_hook /* The address of a function to call periodically while Readline is awaiting character input, or NULL, for no event handling. */ extern Function *rl_event_hook; /* Non-zero means that modified history lines are preceded with an asterisk. */ extern int rl_show_star; /* Non-zero means that the results of the matches are to be treated as filenames. This is ALWAYS zero on entry, and can only be changed within a completion entry finder function. */ extern int rl_filename_completion_desired; /* Non-zero means that the results of the matches are to be quoted using double quotes (or an application-specific quoting mechanism) if the filename contains any characters in rl_word_break_chars. This is ALWAYS non-zero on entry, and can only be changed within a completion entry finder function. */ extern int rl_filename_quoting_desired; /* Non-zero means to suppress normal filename completion after the user-specified completion function has been called. */ extern int rl_attempted_completion_over; /* **************************************************************** */ /* */ /* Well Published Functions */ /* */ /* **************************************************************** */ /* Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. */ extern char *readline (); /* These functions are from complete.c. */ /* Return an array of strings which are the result of repeatadly calling FUNC with TEXT. */ extern char **completion_matches (); extern char *username_completion_function (); extern char *filename_completion_function (); /* These functions are from bind.c. */ /* rl_add_defun (char *name, Function *function, int key) Add NAME to the list of named functions. Make FUNCTION be the function that gets called. If KEY is not -1, then bind it. */ extern int rl_add_defun (); extern int rl_bind_key (), rl_bind_key_in_map (); extern int rl_unbind_key (), rl_unbind_key_in_map (); extern int rl_set_key (); extern int rl_macro_bind (), rl_generic_bind (), rl_variable_bind (); extern int rl_translate_keyseq (); extern Function *rl_named_function (), *rl_function_of_keyseq (); extern int rl_parse_and_bind (); extern Keymap rl_get_keymap (), rl_get_keymap_by_name (); extern void rl_set_keymap (); extern char **rl_invoking_keyseqs (), **rl_invoking_keyseqs_in_map (); extern void rl_function_dumper (); extern int rl_read_init_file (); /* Functions in funmap.c */ extern void rl_list_funmap_names (); extern void rl_initialize_funmap (); /* Functions in display.c */ extern void rl_redisplay (); extern int rl_message (), rl_clear_message (); extern int rl_reset_line_state (); extern int rl_character_len (); extern int rl_show_char (); extern int crlf (), rl_on_new_line (); extern int rl_forced_update_display (); /* Definitions available for use by readline clients. */ #define RL_PROMPT_START_IGNORE '\001' #define RL_PROMPT_END_IGNORE '\002' #if !defined (savestring) extern char *savestring (); /* XXX backwards compatibility */ #endif #endif /* _READLINE_H_ */ lafe/readline/readline.c100644 325 24 234024 6106101044 13466 0ustar dlduser/* readline.c -- a general facility for reading lines of input with emacs style editing and completion. */ /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc. This file is part of the GNU Readline Library, a library for reading lines of text with interactive input and history editing. The GNU Readline Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The GNU Readline Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #define READLINE_LIBRARY #include #include #include #if !defined (NO_SYS_FILE) # include #endif /* !NO_SYS_FILE */ #include #if defined (HAVE_UNISTD_H) # include #endif /* HAVE_UNISTD_H */ #if defined (HAVE_STDLIB_H) # include #else # include "ansi_stdlib.h" #endif /* HAVE_STDLIB_H */ #include /* Not all systems declare ERRNO in errno.h... and some systems #define it! */ #if !defined (errno) extern int errno; #endif /* !errno */ #include #include "posixstat.h" /* System-specific feature definitions and include files. */ #include "rldefs.h" #if defined (GWINSZ_IN_SYS_IOCTL) || (defined (VSTATUS) && !defined (SunOS4)) # include #endif /* GWINSZ_IN_SYS_IOCTL || VSTATUS */ /* Some standard library routines. */ #include "readline.h" #include "history.h" /* NOTE: Functions and variables prefixed with `_rl_' are pseudo-global: they are global so they can be shared between files in the readline library, but are not intended to be visible to readline callers. */ /* Functions imported from other files in the library. */ extern char *tgetstr (); extern void rl_prep_terminal (), rl_deprep_terminal (); extern void _rl_bind_if_unbound (); /* External redisplay functions and variables from display.c */ extern void _rl_move_vert (); extern void _rl_update_final (); extern void _rl_erase_at_end_of_line (); extern void _rl_move_cursor_relative (); extern int _rl_vis_botlin; extern int _rl_last_c_pos; extern int _rl_horizontal_scroll_mode; extern int rl_display_fixed; extern char *rl_display_prompt; /* Variables imported from complete.c. */ extern char *rl_completer_word_break_characters; extern char *rl_basic_word_break_characters; extern int rl_completion_query_items; extern int rl_complete_with_tilde_expansion; #if defined (VI_MODE) extern void _rl_vi_set_last (); extern void _rl_vi_reset_last (); extern void _rl_vi_done_inserting (); #endif /* VI_MODE */ /* Forward declarations used in this file. */ void _rl_free_history_entry (); int _rl_dispatch (); void _rl_set_screen_size (); int _rl_output_character_function (); static char *readline_internal (); static void readline_initialize_everything (); static int init_terminal_io (); static void start_using_history (); static void bind_arrow_keys (); #if !defined (__GO32__) static void readline_default_bindings (); #endif /* !__GO32__ */ #if defined (__GO32__) # include # undef HANDLE_SIGNALS #endif /* __GO32__ */ #if defined (STATIC_MALLOC) static char *xmalloc (), *xrealloc (); #else extern char *xmalloc (), *xrealloc (); #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Line editing input utility */ /* */ /* **************************************************************** */ static char *LibraryVersion = "2.0"; /* A pointer to the keymap that is currently in use. By default, it is the standard emacs keymap. */ Keymap _rl_keymap = emacs_standard_keymap; /* The current style of editing. */ int rl_editing_mode = emacs_mode; /* Non-zero if the previous command was a kill command. */ static int last_command_was_kill = 0; /* The current value of the numeric argument specified by the user. */ int rl_numeric_arg = 1; /* Non-zero if an argument was typed. */ int rl_explicit_arg = 0; /* Temporary value used while generating the argument. */ int rl_arg_sign = 1; /* Non-zero means we have been called at least once before. */ static int rl_initialized = 0; /* If non-zero, this program is running in an EMACS buffer. */ static int running_in_emacs = 0; /* The current offset in the current input line. */ int rl_point; /* Mark in the current input line. */ int rl_mark; /* Length of the current input line. */ int rl_end; /* Make this non-zero to return the current input_line. */ int rl_done; /* The last function executed by readline. */ Function *rl_last_func = (Function *)NULL; /* Top level environment for readline_internal (). */ static jmp_buf readline_top_level; /* The streams we interact with. */ static FILE *in_stream, *out_stream; /* The names of the streams that we do input and output to. */ FILE *rl_instream = (FILE *)NULL; FILE *rl_outstream = (FILE *)NULL; /* Non-zero means echo characters as they are read. */ int readline_echoing_p = 1; /* Current prompt. */ char *rl_prompt; int rl_visible_prompt_length = 0; /* The number of characters read in order to type this complete command. */ int rl_key_sequence_length = 0; /* If non-zero, then this is the address of a function to call just before readline_internal () prints the first prompt. */ Function *rl_startup_hook = (Function *)NULL; /* What we use internally. You should always refer to RL_LINE_BUFFER. */ static char *the_line; /* The character that can generate an EOF. Really read from the terminal driver... just defaulted here. */ int _rl_eof_char = CTRL ('D'); /* Non-zero makes this the next keystroke to read. */ int rl_pending_input = 0; /* Pointer to a useful terminal name. */ char *rl_terminal_name = (char *)NULL; /* Non-zero means to always use horizontal scrolling in line display. */ int _rl_horizontal_scroll_mode = 0; /* Non-zero means to display an asterisk at the starts of history lines which have been modified. */ int _rl_mark_modified_lines = 0; /* The style of `bell' notification preferred. This can be set to NO_BELL, AUDIBLE_BELL, or VISIBLE_BELL. */ int _rl_bell_preference = AUDIBLE_BELL; /* Line buffer and maintenence. */ char *rl_line_buffer = (char *)NULL; int rl_line_buffer_len = 0; #define DEFAULT_BUFFER_SIZE 256 /* Forward declarations used by the display and termcap code. */ int term_xn; int screenwidth, screenheight, screenchars; /* **************************************************************** */ /* */ /* `Forward' declarations */ /* */ /* **************************************************************** */ /* Non-zero means do not parse any lines other than comments and parser directives. */ unsigned char _rl_parsing_conditionalized_out = 0; /* Non-zero means to save keys that we dispatch on in a kbd macro. */ static int defining_kbd_macro = 0; /* Non-zero means to convert characters with the meta bit set to escape-prefixed characters so we can indirect through emacs_meta_keymap or vi_escape_keymap. */ int _rl_convert_meta_chars_to_ascii = 1; /* Non-zero means to output characters with the meta bit set directly rather than as a meta-prefixed escape sequence. */ int _rl_output_meta_chars = 0; /* Non-zero tells rl_delete_text and rl_insert_text to not add to the undo list. */ static int doing_an_undo = 0; /* **************************************************************** */ /* */ /* Top Level Functions */ /* */ /* **************************************************************** */ /* Non-zero means treat 0200 bit in terminal input as Meta bit. */ int _rl_meta_flag = 0; /* Forward declaration */ /* Read a line of input. Prompt with PROMPT. A NULL PROMPT means none. A return value of NULL means that EOF was encountered. */ char * readline (prompt) char *prompt; { char *value; rl_prompt = prompt; /* If we are at EOF return a NULL string. */ if (rl_pending_input == EOF) { rl_pending_input = 0; return ((char *)NULL); } rl_visible_prompt_length = rl_expand_prompt (rl_prompt); rl_initialize (); rl_prep_terminal (_rl_meta_flag); #if defined (HANDLE_SIGNALS) rl_set_signals (); #endif value = readline_internal (); rl_deprep_terminal (); #if defined (HANDLE_SIGNALS) rl_clear_signals (); #endif return (value); } /* Read a line of input from the global rl_instream, doing output on the global rl_outstream. If rl_prompt is non-null, then that is our prompt. */ static char * readline_internal () { int lastc, c, eof_found; in_stream = rl_instream; out_stream = rl_outstream; lastc = -1; eof_found = 0; if (rl_startup_hook) (*rl_startup_hook) (); if (!readline_echoing_p) { if (rl_prompt) { fprintf (out_stream, "%s", rl_prompt); fflush (out_stream); } } else { rl_on_new_line (); rl_redisplay (); #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_vi_insertion_mode (); #endif /* VI_MODE */ } while (!rl_done) { int lk = last_command_was_kill; int code; code = setjmp (readline_top_level); if (code) rl_redisplay (); if (!rl_pending_input) { /* Then initialize the argument and number of keys read. */ rl_init_argument (); rl_key_sequence_length = 0; } c = rl_read_key (); /* EOF typed to a non-blank line is a . */ if (c == EOF && rl_end) c = NEWLINE; /* The character _rl_eof_char typed to blank line, and not as the previous character is interpreted as EOF. */ if (((c == _rl_eof_char && lastc != c) || c == EOF) && !rl_end) { eof_found = 1; break; } lastc = c; _rl_dispatch (c, _rl_keymap); /* If there was no change in last_command_was_kill, then no kill has taken place. Note that if input is pending we are reading a prefix command, so nothing has changed yet. */ if (!rl_pending_input) { if (lk == last_command_was_kill) last_command_was_kill = 0; } #if defined (VI_MODE) /* In vi mode, when you exit insert mode, the cursor moves back over the previous character. We explicitly check for that here. */ if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap) rl_vi_check (); #endif /* VI_MODE */ if (!rl_done) rl_redisplay (); } /* Restore the original of this history line, iff the line that we are editing was originally in the history, AND the line has changed. */ { HIST_ENTRY *entry = current_history (); if (entry && rl_undo_list) { char *temp = savestring (the_line); rl_revert_line (); entry = replace_history_entry (where_history (), the_line, (HIST_ENTRY *)NULL); _rl_free_history_entry (entry); strcpy (the_line, temp); free (temp); } } /* At any rate, it is highly likely that this line has an undo list. Get rid of it now. */ if (rl_undo_list) free_undo_list (); if (eof_found) return (char *)NULL; else return (savestring (the_line)); } /* **************************************************************** */ /* */ /* Character Input Buffering */ /* */ /* **************************************************************** */ static int pop_index = 0, push_index = 0, ibuffer_len = 511; static unsigned char ibuffer[512]; /* Non-null means it is a pointer to a function to run while waiting for character input. */ Function *rl_event_hook = (Function *)NULL; #define any_typein (push_index != pop_index) /* Add KEY to the buffer of characters to be read. */ rl_stuff_char (key) int key; { if (key == EOF) { key = NEWLINE; rl_pending_input = EOF; } ibuffer[push_index++] = key; if (push_index >= ibuffer_len) push_index = 0; return push_index; } /* Return the amount of space available in the buffer for stuffing characters. */ int ibuffer_space () { if (pop_index > push_index) return (pop_index - push_index); else return (ibuffer_len - (push_index - pop_index)); } /* Get a key from the buffer of characters to be read. Return the key in KEY. Result is KEY if there was a key, or 0 if there wasn't. */ int rl_get_char (key) int *key; { if (push_index == pop_index) return (0); *key = ibuffer[pop_index++]; if (pop_index >= ibuffer_len) pop_index = 0; return (1); } /* Stuff KEY into the *front* of the input buffer. Returns non-zero if successful, zero if there is no space left in the buffer. */ int rl_unget_char (key) int key; { if (ibuffer_space ()) { pop_index--; if (pop_index < 0) pop_index = ibuffer_len - 1; ibuffer[pop_index] = key; return (1); } return (0); } /* If a character is available to be read, then read it and stuff it into IBUFFER. Otherwise, just return. */ void rl_gather_tyi () { #if defined (__GO32__) char input; if (isatty (0)) { int i = rl_getc (); if (i != EOF) rl_stuff_char (i); } else if (kbhit () && ibuffer_space ()) rl_stuff_char (getkey ()); #else /* !__GO32__ */ int tty = fileno (in_stream); register int tem, result = -1; int chars_avail; char input; #if defined (FIONREAD) result = ioctl (tty, FIONREAD, &chars_avail); #endif #if defined (O_NDELAY) if (result == -1) { int flags; flags = fcntl (tty, F_GETFL, 0); fcntl (tty, F_SETFL, (flags | O_NDELAY)); chars_avail = read (tty, &input, 1); fcntl (tty, F_SETFL, flags); if (chars_avail == -1 && errno == EAGAIN) return; } #endif /* O_NDELAY */ /* If there's nothing available, don't waste time trying to read something. */ if (chars_avail == 0) return; tem = ibuffer_space (); if (chars_avail > tem) chars_avail = tem; /* One cannot read all of the available input. I can only read a single character at a time, or else programs which require input can be thwarted. If the buffer is larger than one character, I lose. Damn! */ if (tem < ibuffer_len) chars_avail = 0; if (result != -1) { while (chars_avail--) rl_stuff_char (rl_getc (in_stream)); } else { if (chars_avail) rl_stuff_char (input); } #endif /* !__GO32__ */ } static int next_macro_key (); /* Read a key, including pending input. */ int rl_read_key () { int c; rl_key_sequence_length++; if (rl_pending_input) { c = rl_pending_input; rl_pending_input = 0; } else { /* If input is coming from a macro, then use that. */ if (c = next_macro_key ()) return (c); /* If the user has an event function, then call it periodically. */ if (rl_event_hook) { while (rl_event_hook && !rl_get_char (&c)) { (*rl_event_hook) (); rl_gather_tyi (); } } else { if (!rl_get_char (&c)) c = rl_getc (in_stream); } } return (c); } /* Found later in this file. */ static void add_macro_char (), with_macro_input (); /* Do the command associated with KEY in MAP. If the associated command is really a keymap, then read another key, and dispatch into that map. */ int _rl_dispatch (key, map) register int key; Keymap map; { int r = 0; if (defining_kbd_macro) add_macro_char (key); if (META_CHAR (key) && _rl_convert_meta_chars_to_ascii) { if (map[ESC].type == ISKMAP) { map = FUNCTION_TO_KEYMAP (map, ESC); key = UNMETA (key); rl_key_sequence_length += 2; return (_rl_dispatch (key, map)); } else ding (); return 0; } switch (map[key].type) { case ISFUNC: { Function *func = map[key].function; if (func != (Function *)NULL) { /* Special case rl_do_lowercase_version (). */ if (func == rl_do_lowercase_version) return (_rl_dispatch (to_lower (key), map)); r = (*map[key].function)(rl_numeric_arg * rl_arg_sign, key); /* If we have input pending, then the last command was a prefix command. Don't change the state of rl_last_func. Otherwise, remember the last command executed in this variable. */ if (!rl_pending_input) rl_last_func = map[key].function; } else { rl_abort (); return -1; } } break; case ISKMAP: if (map[key].function != (Function *)NULL) { int newkey; rl_key_sequence_length++; newkey = rl_read_key (); r = _rl_dispatch (newkey, FUNCTION_TO_KEYMAP (map, key)); } else { rl_abort (); return -1; } break; case ISMACR: if (map[key].function != (Function *)NULL) { char *macro; macro = savestring ((char *)map[key].function); with_macro_input (macro); return 0; } break; } #if defined (VI_MODE) if (rl_editing_mode == vi_mode && _rl_keymap == vi_movement_keymap && rl_vi_textmod_command (key)) _rl_vi_set_last (key, rl_numeric_arg, rl_arg_sign); #endif return (r); } /* **************************************************************** */ /* */ /* Hacking Keyboard Macros */ /* */ /* **************************************************************** */ /* The currently executing macro string. If this is non-zero, then it is a malloc ()'ed string where input is coming from. */ static char *executing_macro = (char *)NULL; /* The offset in the above string to the next character to be read. */ static int executing_macro_index = 0; /* The current macro string being built. Characters get stuffed in here by add_macro_char (). */ static char *current_macro = (char *)NULL; /* The size of the buffer allocated to current_macro. */ static int current_macro_size = 0; /* The index at which characters are being added to current_macro. */ static int current_macro_index = 0; /* A structure used to save nested macro strings. It is a linked list of string/index for each saved macro. */ struct saved_macro { struct saved_macro *next; char *string; int sindex; }; /* The list of saved macros. */ struct saved_macro *macro_list = (struct saved_macro *)NULL; /* Forward declarations of static functions. Thank you C. */ static void push_executing_macro (), pop_executing_macro (); /* This one has to be declared earlier in the file. */ /* static void add_macro_char (); */ /* Set up to read subsequent input from STRING. STRING is free ()'ed when we are done with it. */ static void with_macro_input (string) char *string; { push_executing_macro (); executing_macro = string; executing_macro_index = 0; } /* Return the next character available from a macro, or 0 if there are no macro characters. */ static int next_macro_key () { if (!executing_macro) return (0); if (!executing_macro[executing_macro_index]) { pop_executing_macro (); return (next_macro_key ()); } return (executing_macro[executing_macro_index++]); } /* Save the currently executing macro on a stack of saved macros. */ static void push_executing_macro () { struct saved_macro *saver; saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro)); saver->next = macro_list; saver->sindex = executing_macro_index; saver->string = executing_macro; macro_list = saver; } /* Discard the current macro, replacing it with the one on the top of the stack of saved macros. */ static void pop_executing_macro () { if (executing_macro) free (executing_macro); executing_macro = (char *)NULL; executing_macro_index = 0; if (macro_list) { struct saved_macro *disposer = macro_list; executing_macro = macro_list->string; executing_macro_index = macro_list->sindex; macro_list = macro_list->next; free (disposer); } } /* Add a character to the macro being built. */ static void add_macro_char (c) int c; { if (current_macro_index + 1 >= current_macro_size) { if (!current_macro) current_macro = xmalloc (current_macro_size = 25); else current_macro = xrealloc (current_macro, current_macro_size += 25); } current_macro[current_macro_index++] = c; current_macro[current_macro_index] = '\0'; } /* Begin defining a keyboard macro. Keystrokes are recorded as they are executed. End the definition with rl_end_kbd_macro (). If a numeric argument was explicitly typed, then append this definition to the end of the existing macro, and start by re-executing the existing macro. */ rl_start_kbd_macro (ignore1, ignore2) int ignore1, ignore2; { if (defining_kbd_macro) { rl_abort (); return -1; } if (rl_explicit_arg) { if (current_macro) with_macro_input (savestring (current_macro)); } else current_macro_index = 0; defining_kbd_macro = 1; return 0; } /* Stop defining a keyboard macro. A numeric argument says to execute the macro right now, that many times, counting the definition as the first time. */ rl_end_kbd_macro (count, ignore) int count, ignore; { if (!defining_kbd_macro) { rl_abort (); return -1; } current_macro_index -= (rl_key_sequence_length - 1); current_macro[current_macro_index] = '\0'; defining_kbd_macro = 0; return (rl_call_last_kbd_macro (--count, 0)); } /* Execute the most recently defined keyboard macro. COUNT says how many times to execute it. */ rl_call_last_kbd_macro (count, ignore) int count, ignore; { if (!current_macro) rl_abort (); if (defining_kbd_macro) { ding (); /* no recursive macros */ current_macro[--current_macro_index] = '\0'; /* erase this char */ return 0; } while (count--) with_macro_input (savestring (current_macro)); return 0; } void _rl_kill_kbd_macro () { if (current_macro) { free (current_macro); current_macro = (char *) NULL; } current_macro_size = current_macro_index = 0; if (executing_macro) { free (executing_macro); executing_macro = (char *) NULL; } executing_macro_index = 0; defining_kbd_macro = 0; } /* **************************************************************** */ /* */ /* Initializations */ /* */ /* **************************************************************** */ /* Initliaze readline (and terminal if not already). */ rl_initialize () { char *t; /* If we have never been called before, initialize the terminal and data structures. */ if (!rl_initialized) { readline_initialize_everything (); rl_initialized++; } /* Initalize the current line information. */ rl_point = rl_end = 0; the_line = rl_line_buffer; the_line[0] = 0; /* We aren't done yet. We haven't even gotten started yet! */ rl_done = 0; /* Check for LC_CTYPE and use its value to decide the defaults for 8-bit character input and output. */ t = getenv ("LC_CTYPE"); if (t && (strcmp (t, "iso-8859-1") == 0 || strcmp (t, "iso_8859_1") == 0)) { _rl_meta_flag = 1; _rl_convert_meta_chars_to_ascii = 0; _rl_output_meta_chars = 1; } /* Tell the history routines what is going on. */ start_using_history (); /* Make the display buffer match the state of the line. */ rl_reset_line_state (); /* No such function typed yet. */ rl_last_func = (Function *)NULL; /* Parsing of key-bindings begins in an enabled state. */ _rl_parsing_conditionalized_out = 0; return 0; } /* Initialize the entire state of the world. */ static void readline_initialize_everything () { /* Find out if we are running in Emacs. */ running_in_emacs = getenv ("EMACS") != (char *)0; /* Set up input and output if they are not already set up. */ if (!rl_instream) rl_instream = stdin; if (!rl_outstream) rl_outstream = stdout; /* Bind in_stream and out_stream immediately. These values may change, but they may also be used before readline_internal () is called. */ in_stream = rl_instream; out_stream = rl_outstream; /* Allocate data structures. */ if (!rl_line_buffer) rl_line_buffer = xmalloc (rl_line_buffer_len = DEFAULT_BUFFER_SIZE); /* Initialize the terminal interface. */ init_terminal_io ((char *)NULL); #if !defined (__GO32__) /* Bind tty characters to readline functions. */ readline_default_bindings (); #endif /* !__GO32__ */ /* Initialize the function names. */ rl_initialize_funmap (); /* Read in the init file. */ rl_read_init_file ((char *)NULL); /* XXX */ if (_rl_horizontal_scroll_mode && term_xn) { screenwidth--; screenchars -= screenheight; } /* Override the effect of any `set keymap' assignments in the inputrc file. */ rl_set_keymap_from_edit_mode (); /* Try to bind a common arrow key prefix, if not already bound. */ bind_arrow_keys (); /* If the completion parser's default word break characters haven't been set yet, then do so now. */ if (rl_completer_word_break_characters == (char *)NULL) rl_completer_word_break_characters = rl_basic_word_break_characters; } /* If this system allows us to look at the values of the regular input editing characters, then bind them to their readline equivalents, iff the characters are not bound to keymaps. */ static void readline_default_bindings () { rltty_set_default_bindings (_rl_keymap); } static void bind_arrow_keys_internal () { Function *f; f = rl_function_of_keyseq ("\033[A", _rl_keymap, (int *)NULL); if (!f || f == rl_do_lowercase_version) { _rl_bind_if_unbound ("\033[A", rl_get_previous_history); _rl_bind_if_unbound ("\033[B", rl_get_next_history); _rl_bind_if_unbound ("\033[C", rl_forward); _rl_bind_if_unbound ("\033[D", rl_backward); } f = rl_function_of_keyseq ("\033OA", _rl_keymap, (int *)NULL); if (!f || f == rl_do_lowercase_version) { _rl_bind_if_unbound ("\033OA", rl_get_previous_history); _rl_bind_if_unbound ("\033OB", rl_get_next_history); _rl_bind_if_unbound ("\033OC", rl_forward); _rl_bind_if_unbound ("\033OD", rl_backward); } } /* Try and bind the common arrow key prefix after giving termcap and the inputrc file a chance to bind them and create `real' keymaps for the arrow key prefix. */ static void bind_arrow_keys () { Keymap xkeymap; xkeymap = _rl_keymap; _rl_keymap = emacs_standard_keymap; bind_arrow_keys_internal (); #if defined (VI_MODE) _rl_keymap = vi_movement_keymap; bind_arrow_keys_internal (); #endif _rl_keymap = xkeymap; } /* **************************************************************** */ /* */ /* Numeric Arguments */ /* */ /* **************************************************************** */ /* Handle C-u style numeric args, as well as M--, and M-digits. */ static int rl_digit_loop () { int key, c; while (1) { rl_message ("(arg: %d) ", rl_arg_sign * rl_numeric_arg); key = c = rl_read_key (); if (_rl_keymap[c].type == ISFUNC && _rl_keymap[c].function == rl_universal_argument) { rl_numeric_arg *= 4; continue; } c = UNMETA (c); if (digit_p (c)) { if (rl_explicit_arg) rl_numeric_arg = (rl_numeric_arg * 10) + (c - '0'); else rl_numeric_arg = (c - '0'); rl_explicit_arg = 1; } else { if (c == '-' && !rl_explicit_arg) { rl_numeric_arg = 1; rl_arg_sign = -1; } else { rl_clear_message (); return (_rl_dispatch (key, _rl_keymap)); } } } return 0; } /* Add the current digit to the argument in progress. */ rl_digit_argument (ignore, key) int ignore, key; { rl_pending_input = key; return (rl_digit_loop ()); } /* What to do when you abort reading an argument. */ rl_discard_argument () { ding (); rl_clear_message (); rl_init_argument (); return 0; } /* Create a default argument. */ rl_init_argument () { rl_numeric_arg = rl_arg_sign = 1; rl_explicit_arg = 0; return 0; } /* C-u, universal argument. Multiply the current argument by 4. Read a key. If the key has nothing to do with arguments, then dispatch on it. If the key is the abort character then abort. */ rl_universal_argument () { rl_numeric_arg *= 4; return (rl_digit_loop ()); } /* **************************************************************** */ /* */ /* Terminal and Termcap */ /* */ /* **************************************************************** */ static char *term_buffer = (char *)NULL; static char *term_string_buffer = (char *)NULL; static int tcap_initialized = 0; /* Non-zero means this terminal can't really do anything. */ int dumb_term = 0; /* On Solaris2, sys/types.h #includes sys/reg.h, which #defines PC. Unfortunately, PC is a global variable used by the termcap library. */ #undef PC #if !defined (__linux__) /* If this causes problems, remove the `extern'. */ /* sgi systems seem to want this, AIX doesn't. */ #if defined(sgi) extern #endif char PC, *BC, *UP; #endif /* __linux__ */ /* Some strings to control terminal actions. These are output by tputs (). */ char *term_goto, *term_clreol, *term_cr, *term_clrpag, *term_backspace; char *term_pc; /* Non-zero if we determine that the terminal can do character insertion. */ int terminal_can_insert = 0; /* How to insert characters. */ char *term_im, *term_ei, *term_ic, *term_ip, *term_IC; /* How to delete characters. */ char *term_dc, *term_DC; #if defined (HACK_TERMCAP_MOTION) char *term_forward_char; #endif /* HACK_TERMCAP_MOTION */ /* How to go up a line. */ char *term_up; /* A visible bell, if the terminal can be made to flash the screen. */ char *visible_bell; /* Non-zero means that this terminal has a meta key. */ int term_has_meta; /* The string to write to turn on the meta key, if this term has one. */ char *term_mm; /* The string to write to turn off the meta key, if this term has one. */ char *term_mo; /* The key sequences output by the arrow keys, if this terminal has any. */ char *term_ku, *term_kd, *term_kr, *term_kl; /* How to initialize and reset the arrow keys, if this terminal has any. */ char *term_ks, *term_ke; /* Re-initialize the terminal considering that the TERM/TERMCAP variable has changed. */ rl_reset_terminal (terminal_name) char *terminal_name; { init_terminal_io (terminal_name); return 0; } /* Set readline's idea of the screen size. TTY is a file descriptor open to the terminal. If IGNORE_ENV is true, we do not pay attention to the values of $LINES and $COLUMNS. The tests for TERM_STRING_BUFFER being non-null serve to check whether or not we have initialized termcap. */ void _rl_set_screen_size (tty, ignore_env) int tty, ignore_env; { #if defined (TIOCGWINSZ) struct winsize window_size; #endif /* TIOCGWINSZ */ #if defined (TIOCGWINSZ) if (ioctl (tty, TIOCGWINSZ, &window_size) == 0) { screenwidth = (int) window_size.ws_col; screenheight = (int) window_size.ws_row; } #endif /* TIOCGWINSZ */ /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV is unset. */ if (screenwidth <= 0) { char *sw; if (!ignore_env && (sw = getenv ("COLUMNS"))) screenwidth = atoi (sw); if (screenwidth <= 0 && term_string_buffer) screenwidth = tgetnum ("co"); } /* Environment variable LINES overrides setting of "li" if IGNORE_ENV is unset. */ if (screenheight <= 0) { char *sh; if (!ignore_env && (sh = getenv ("LINES"))) screenheight = atoi (sh); if (screenheight <= 0 && term_string_buffer) screenheight = tgetnum ("li"); } /* If all else fails, default to 80x24 terminal. */ if (screenwidth <= 1) screenwidth = 80; if (screenheight <= 0) screenheight = 24; #if defined (SHELL) /* If we're being compiled as part of bash, set the environment variables $LINES and $COLUMNS to new values. */ set_lines_and_columns (screenheight, screenwidth); #endif if (!term_xn) screenwidth--; screenchars = screenwidth * screenheight; } struct _tc_string { char *tc_var; char **tc_value; }; /* This should be kept sorted, just in case we decide to change the search algorithm to something smarter. */ static struct _tc_string tc_strings[] = { "DC", &term_DC, "IC", &term_IC, "ce", &term_clreol, "cl", &term_clrpag, "cr", &term_cr, "dc", &term_dc, "ei", &term_ei, "ic", &term_ic, "im", &term_im, "kd", &term_kd, "kl", &term_kl, "kr", &term_kr, "ku", &term_ku, "ks", &term_ks, "ke", &term_ke, "le", &term_backspace, "mm", &term_mm, "mo", &term_mo, #if defined (HACK_TERMCAP_MOTION) "nd", &term_forward_char, #endif "pc", &term_pc, "up", &term_up, "vb", &visible_bell, }; #define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string)) /* Read the desired terminal capability strings into BP. The capabilities are described in the TC_STRINGS table. */ static void get_term_capabilities (bp) char **bp; { register int i; for (i = 0; i < NUM_TC_STRINGS; i++) *(tc_strings[i].tc_value) = tgetstr (tc_strings[i].tc_var, bp); tcap_initialized = 1; } static int init_terminal_io (terminal_name) char *terminal_name; { #if defined (__GO32__) screenwidth = ScreenCols (); screenheight = ScreenRows (); screenchars = screenwidth * screenheight; term_cr = "\r"; term_im = term_ei = term_ic = term_IC = (char *)NULL; term_up = term_dc = term_DC = visible_bell = (char *)NULL; /* Does the __GO32__ have a meta key? I don't know. */ term_has_meta = 0; term_mm = term_mo = (char *)NULL; /* It probably has arrow keys, but I don't know what they are. */ term_ku = term_kd = term_kr = term_kl = (char *)NULL; #if defined (HACK_TERMCAP_MOTION) term_forward_char = (char *)NULL; #endif /* HACK_TERMCAP_MOTION */ terminal_can_insert = term_xn = 0; return; #else /* !__GO32__ */ char *term, *buffer; int tty; Keymap xkeymap; term = terminal_name ? terminal_name : getenv ("TERM"); if (!term_string_buffer) term_string_buffer = xmalloc (2048); if (!term_buffer) term_buffer = xmalloc (2048); buffer = term_string_buffer; term_clrpag = term_cr = term_clreol = (char *)NULL; if (!term) term = "dumb"; if (tgetent (term_buffer, term) <= 0) { dumb_term = 1; screenwidth = 79; screenheight = 24; screenchars = 79 * 24; term_cr = "\r"; term_im = term_ei = term_ic = term_IC = (char *)NULL; term_up = term_dc = term_DC = visible_bell = (char *)NULL; term_ku = term_kd = term_kl = term_kr = (char *)NULL; #if defined (HACK_TERMCAP_MOTION) term_forward_char = (char *)NULL; #endif terminal_can_insert = 0; return 0; } get_term_capabilities (&buffer); /* Set up the variables that the termcap library expects the application to provide. */ PC = term_pc ? *term_pc : 0; BC = term_backspace; UP = term_up; if (!term_cr) term_cr = "\r"; if (rl_instream) tty = fileno (rl_instream); else tty = 0; screenwidth = screenheight = 0; term_xn = tgetflag ("am") && tgetflag ("xn"); _rl_set_screen_size (tty, 0); /* "An application program can assume that the terminal can do character insertion if *any one of* the capabilities `IC', `im', `ic' or `ip' is provided." But we can't do anything if only `ip' is provided, so... */ terminal_can_insert = (term_IC || term_im || term_ic); /* Check to see if this terminal has a meta key and clear the capability variables if there is none. */ term_has_meta = (tgetflag ("km") || tgetflag ("MT")); if (!term_has_meta) { term_mm = (char *)NULL; term_mo = (char *)NULL; } /* Attempt to find and bind the arrow keys. Do not override already bound keys in an overzealous attempt, however. */ xkeymap = _rl_keymap; _rl_keymap = emacs_standard_keymap; _rl_bind_if_unbound (term_ku, rl_get_previous_history); _rl_bind_if_unbound (term_kd, rl_get_next_history); _rl_bind_if_unbound (term_kr, rl_forward); _rl_bind_if_unbound (term_kl, rl_backward); #if defined (VI_MODE) _rl_keymap = vi_movement_keymap; _rl_bind_if_unbound (term_ku, rl_get_previous_history); _rl_bind_if_unbound (term_kd, rl_get_next_history); _rl_bind_if_unbound (term_kr, rl_forward); _rl_bind_if_unbound (term_kl, rl_backward); #endif /* VI_MODE */ _rl_keymap = xkeymap; #endif /* !__GO32__ */ return 0; } char * rl_get_termcap (cap) char *cap; { register int i; if (tcap_initialized == 0) return ((char *)NULL); for (i = 0; i < NUM_TC_STRINGS; i++) { if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0) return *(tc_strings[i].tc_value); } return ((char *)NULL); } /* A function for the use of tputs () */ int _rl_output_character_function (c) int c; { return putc (c, out_stream); } /* Write COUNT characters from STRING to the output stream. */ void _rl_output_some_chars (string, count) char *string; int count; { fwrite (string, 1, count, out_stream); } /* Move the cursor back. */ backspace (count) int count; { register int i; #if !defined (__GO32__) if (term_backspace) for (i = 0; i < count; i++) tputs (term_backspace, 1, _rl_output_character_function); else #endif /* !__GO32__ */ for (i = 0; i < count; i++) putc ('\b', out_stream); return 0; } /* Move to the start of the next line. */ crlf () { #if defined (NEW_TTY_DRIVER) tputs (term_cr, 1, _rl_output_character_function); #endif /* NEW_TTY_DRIVER */ putc ('\n', out_stream); return 0; } rl_tty_status (count, key) int count, key; { #if defined (TIOCSTAT) ioctl (1, TIOCSTAT, (char *)0); rl_refresh_line (); #else ding (); #endif return 0; } /* **************************************************************** */ /* */ /* Utility Functions */ /* */ /* **************************************************************** */ /* Return 0 if C is not a member of the class of characters that belong in words, or 1 if it is. */ int allow_pathname_alphabetic_chars = 0; char *pathname_alphabetic_chars = "/-_=~.#$"; int alphabetic (c) int c; { if (pure_alphabetic (c) || (digit_p (c))) return (1); if (allow_pathname_alphabetic_chars) return (strchr (pathname_alphabetic_chars, c) != NULL); else return (0); } /* Ring the terminal bell. */ int ding () { if (readline_echoing_p) { #if !defined (__GO32__) switch (_rl_bell_preference) { case NO_BELL: default: break; case VISIBLE_BELL: if (visible_bell) { tputs (visible_bell, 1, _rl_output_character_function); break; } /* FALLTHROUGH */ case AUDIBLE_BELL: fprintf (stderr, "\007"); fflush (stderr); break; } #else /* __GO32__ */ fprintf (stderr, "\007"); fflush (stderr); #endif /* __GO32__ */ return (0); } return (-1); } /* How to abort things. */ rl_abort (count, key) int count, key; { ding (); rl_clear_message (); rl_init_argument (); rl_pending_input = 0; defining_kbd_macro = 0; while (executing_macro) pop_executing_macro (); rl_last_func = (Function *)NULL; longjmp (readline_top_level, 1); } /* Return a copy of the string between FROM and TO. FROM is inclusive, TO is not. */ char * rl_copy_text (from, to) int from, to; { register int length; char *copy; /* Fix it if the caller is confused. */ if (from > to) { int t = from; from = to; to = t; } length = to - from; copy = xmalloc (1 + length); strncpy (copy, the_line + from, length); copy[length] = '\0'; return (copy); } /* Increase the size of RL_LINE_BUFFER until it has enough space to hold LEN characters. */ void rl_extend_line_buffer (len) int len; { while (len >= rl_line_buffer_len) { rl_line_buffer_len += DEFAULT_BUFFER_SIZE; rl_line_buffer = xrealloc (rl_line_buffer, rl_line_buffer_len); } the_line = rl_line_buffer; } /* **************************************************************** */ /* */ /* Insert and Delete */ /* */ /* **************************************************************** */ /* Insert a string of text into the line at point. This is the only way that you should do insertion. rl_insert () calls this function. */ rl_insert_text (string) char *string; { register int i, l = strlen (string); if (rl_end + l >= rl_line_buffer_len) rl_extend_line_buffer (rl_end + l); for (i = rl_end; i >= rl_point; i--) the_line[i + l] = the_line[i]; strncpy (the_line + rl_point, string, l); /* Remember how to undo this if we aren't undoing something. */ if (!doing_an_undo) { /* If possible and desirable, concatenate the undos. */ if ((l == 1) && rl_undo_list && (rl_undo_list->what == UNDO_INSERT) && (rl_undo_list->end == rl_point) && (rl_undo_list->end - rl_undo_list->start < 20)) rl_undo_list->end++; else rl_add_undo (UNDO_INSERT, rl_point, rl_point + l, (char *)NULL); } rl_point += l; rl_end += l; the_line[rl_end] = '\0'; return l; } /* Delete the string between FROM and TO. FROM is inclusive, TO is not. */ rl_delete_text (from, to) int from, to; { register char *text; register int diff, i; /* Fix it if the caller is confused. */ if (from > to) { int t = from; from = to; to = t; } text = rl_copy_text (from, to); /* Some versions of strncpy() can't handle overlapping arguments. */ diff = to - from; for (i = from; i < rl_end - diff; i++) the_line[i] = the_line[i + diff]; /* Remember how to undo this delete. */ if (!doing_an_undo) rl_add_undo (UNDO_DELETE, from, to, text); else free (text); rl_end -= diff; the_line[rl_end] = '\0'; return (diff); } /* **************************************************************** */ /* */ /* Readline character functions */ /* */ /* **************************************************************** */ /* This is not a gap editor, just a stupid line input routine. No hair is involved in writing any of the functions, and none should be. */ /* Note that: rl_end is the place in the string that we would place '\0'; i.e., it is always safe to place '\0' there. rl_point is the place in the string where the cursor is. Sometimes this is the same as rl_end. Any command that is called interactively receives two arguments. The first is a count: the numeric arg pased to this command. The second is the key which invoked this command. */ /* **************************************************************** */ /* */ /* Movement Commands */ /* */ /* **************************************************************** */ /* Note that if you `optimize' the display for these functions, you cannot use said functions in other functions which do not do optimizing display. I.e., you will have to update the data base for rl_redisplay, and you might as well let rl_redisplay do that job. */ /* Move forward COUNT characters. */ rl_forward (count, key) int count, key; { if (count < 0) rl_backward (-count); else if (count > 0) { int end = rl_point + count; #if defined (VI_MODE) int lend = rl_end - (rl_editing_mode == vi_mode); #else int lend = rl_end; #endif if (end > lend) { rl_point = lend; ding (); } else rl_point = end; } return 0; } /* Move backward COUNT characters. */ rl_backward (count, key) int count, key; { if (count < 0) rl_forward (-count); else if (count > 0) { if (rl_point < count) { rl_point = 0; ding (); } else rl_point -= count; } return 0; } /* Move to the beginning of the line. */ rl_beg_of_line (count, key) int count, key; { rl_point = 0; return 0; } /* Move to the end of the line. */ rl_end_of_line (count, key) int count, key; { rl_point = rl_end; return 0; } /* Move forward a word. We do what Emacs does. */ rl_forward_word (count, key) int count, key; { int c; if (count < 0) { rl_backward_word (-count); return 0; } while (count) { if (rl_point == rl_end) return 0; /* If we are not in a word, move forward until we are in one. Then, move forward until we hit a non-alphabetic character. */ c = the_line[rl_point]; if (!alphabetic (c)) { while (++rl_point < rl_end) { c = the_line[rl_point]; if (alphabetic (c)) break; } } if (rl_point == rl_end) return 0; while (++rl_point < rl_end) { c = the_line[rl_point]; if (!alphabetic (c)) break; } --count; } return 0; } /* Move backward a word. We do what Emacs does. */ rl_backward_word (count, key) int count, key; { int c; if (count < 0) { rl_forward_word (-count); return 0; } while (count) { if (!rl_point) return 0; /* Like rl_forward_word (), except that we look at the characters just before point. */ c = the_line[rl_point - 1]; if (!alphabetic (c)) { while (--rl_point) { c = the_line[rl_point - 1]; if (alphabetic (c)) break; } } while (rl_point) { c = the_line[rl_point - 1]; if (!alphabetic (c)) break; else --rl_point; } --count; } return 0; } /* Clear the current line. Numeric argument to C-l does this. */ rl_refresh_line () { int curr_line, nleft; /* Find out whether or not there might be invisible characters in the editing buffer. */ if (rl_display_prompt == rl_prompt) nleft = _rl_last_c_pos - screenwidth - rl_visible_prompt_length; else nleft = _rl_last_c_pos - screenwidth; if (nleft > 0) curr_line = 1 + nleft / screenwidth; else curr_line = 0; _rl_move_vert (curr_line); _rl_move_cursor_relative (0, the_line); /* XXX is this right */ #if defined (__GO32__) { int row, col, width, row_start; ScreenGetCursor (&row, &col); width = ScreenCols (); row_start = ScreenPrimary + (row * width); memset (row_start + col, 0, (width - col) * 2); } #else /* !__GO32__ */ if (term_clreol) tputs (term_clreol, 1, _rl_output_character_function); #endif /* !__GO32__ */ rl_forced_update_display (); rl_display_fixed = 1; return 0; } /* C-l typed to a line without quoting clears the screen, and then reprints the prompt and the current input line. Given a numeric arg, redraw only the current line. */ rl_clear_screen (count, key) int count, key; { if (rl_explicit_arg) { rl_refresh_line (); return 0; } #if !defined (__GO32__) if (term_clrpag) tputs (term_clrpag, 1, _rl_output_character_function); else #endif /* !__GO32__ */ crlf (); rl_forced_update_display (); rl_display_fixed = 1; return 0; } rl_arrow_keys (count, c) int count, c; { int ch; ch = rl_read_key (); switch (to_upper (ch)) { case 'A': rl_get_previous_history (count); break; case 'B': rl_get_next_history (count); break; case 'C': rl_forward (count); break; case 'D': rl_backward (count); break; default: ding (); } return 0; } /* **************************************************************** */ /* */ /* Text commands */ /* */ /* **************************************************************** */ /* Insert the character C at the current location, moving point forward. */ rl_insert (count, c) int count, c; { register int i; char *string; if (count <= 0) return 0; /* If we can optimize, then do it. But don't let people crash readline because of extra large arguments. */ if (count > 1 && count < 1024) { string = xmalloc (1 + count); for (i = 0; i < count; i++) string[i] = c; string[i] = '\0'; rl_insert_text (string); free (string); return 0; } if (count > 1024) { int decreaser; char str[1024+1]; for (i = 0; i < 1024; i++) str[i] = c; while (count) { decreaser = (count > 1024 ? 1024 : count); str[decreaser] = '\0'; rl_insert_text (str); count -= decreaser; } return 0; } /* We are inserting a single character. If there is pending input, then make a string of all of the pending characters that are bound to rl_insert, and insert them all. */ if (any_typein) { int key = 0, t; i = 0; string = xmalloc (ibuffer_len + 1); string[i++] = c; while ((t = rl_get_char (&key)) && (_rl_keymap[key].type == ISFUNC && _rl_keymap[key].function == rl_insert)) string[i++] = key; if (t) rl_unget_char (key); string[i] = '\0'; rl_insert_text (string); free (string); } else { /* Inserting a single character. */ char str[2]; str[1] = '\0'; str[0] = c; rl_insert_text (str); } return 0; } /* Insert the next typed character verbatim. */ rl_quoted_insert (count, key) int count, key; { int c; c = rl_read_key (); return (rl_insert (count, c)); } /* Insert a tab character. */ rl_tab_insert (count, key) int count, key; { return (rl_insert (count, '\t')); } /* What to do when a NEWLINE is pressed. We accept the whole line. KEY is the key that invoked this command. I guess it could have meaning in the future. */ rl_newline (count, key) int count, key; { rl_done = 1; #if defined (VI_MODE) _rl_vi_done_inserting (); _rl_vi_reset_last (); #endif /* VI_MODE */ if (readline_echoing_p) _rl_update_final (); return 0; } rl_clean_up_for_exit () { if (readline_echoing_p) { _rl_move_vert (_rl_vis_botlin); _rl_vis_botlin = 0; fflush (out_stream); rl_restart_output (); } return 0; } /* What to do for some uppercase characters, like meta characters, and some characters appearing in emacs_ctlx_keymap. This function is just a stub, you bind keys to it and the code in _rl_dispatch () is special cased. */ rl_do_lowercase_version (ignore1, ignore2) int ignore1, ignore2; { return 0; } /* Rubout the character behind point. */ rl_rubout (count, key) int count, key; { if (count < 0) { rl_delete (-count); return 0; } if (!rl_point) { ding (); return -1; } if (count > 1 || rl_explicit_arg) { int orig_point = rl_point; rl_backward (count); rl_kill_text (orig_point, rl_point); } else { int c = the_line[--rl_point]; rl_delete_text (rl_point, rl_point + 1); if (rl_point == rl_end && isprint (c) && _rl_last_c_pos) { int l; l = rl_character_len (c, rl_point); _rl_erase_at_end_of_line (l); } } return 0; } /* Delete the character under the cursor. Given a numeric argument, kill that many characters instead. */ rl_delete (count, invoking_key) int count, invoking_key; { if (count < 0) { return (rl_rubout (-count)); } if (rl_point == rl_end) { ding (); return -1; } if (count > 1 || rl_explicit_arg) { int orig_point = rl_point; rl_forward (count); rl_kill_text (orig_point, rl_point); rl_point = orig_point; return 0; } else return (rl_delete_text (rl_point, rl_point + 1)); } /* Delete all spaces and tabs around point. */ rl_delete_horizontal_space (count, ignore) int count, ignore; { int start = rl_point; while (rl_point && whitespace (the_line[rl_point - 1])) rl_point--; start = rl_point; while (rl_point < rl_end && whitespace (the_line[rl_point])) rl_point++; if (start != rl_point) { rl_delete_text (start, rl_point); rl_point = start; } return 0; } /* **************************************************************** */ /* */ /* Kill commands */ /* */ /* **************************************************************** */ /* The next two functions mimic unix line editing behaviour, except they save the deleted text on the kill ring. This is safer than not saving it, and since we have a ring, nobody should get screwed. */ /* This does what C-w does in Unix. We can't prevent people from using behaviour that they expect. */ rl_unix_word_rubout (count, key) int count, key; { if (!rl_point) ding (); else { int orig_point = rl_point; while (rl_point && whitespace (the_line[rl_point - 1])) rl_point--; while (rl_point && !whitespace (the_line[rl_point - 1])) rl_point--; rl_kill_text (orig_point, rl_point); } return 0; } /* Here is C-u doing what Unix does. You don't *have* to use these key-bindings. We have a choice of killing the entire line, or killing from where we are to the start of the line. We choose the latter, because if you are a Unix weenie, then you haven't backspaced into the line at all, and if you aren't, then you know what you are doing. */ rl_unix_line_discard (count, key) int count, key; { if (!rl_point) ding (); else { rl_kill_text (rl_point, 0); rl_point = 0; } return 0; } /* **************************************************************** */ /* */ /* Commands For Typos */ /* */ /* **************************************************************** */ /* Random and interesting things in here. */ /* **************************************************************** */ /* */ /* Changing Case */ /* */ /* **************************************************************** */ /* The three kinds of things that we know how to do. */ #define UpCase 1 #define DownCase 2 #define CapCase 3 static int rl_change_case (); /* Uppercase the word at point. */ rl_upcase_word (count, key) int count, key; { return (rl_change_case (count, UpCase)); } /* Lowercase the word at point. */ rl_downcase_word (count, key) int count, key; { return (rl_change_case (count, DownCase)); } /* Upcase the first letter, downcase the rest. */ rl_capitalize_word (count, key) int count, key; { return (rl_change_case (count, CapCase)); } /* The meaty function. Change the case of COUNT words, performing OP on them. OP is one of UpCase, DownCase, or CapCase. If a negative argument is given, leave point where it started, otherwise, leave it where it moves to. */ static int rl_change_case (count, op) int count, op; { register int start = rl_point, end; int state = 0; rl_forward_word (count); end = rl_point; if (count < 0) { int temp = start; start = end; end = temp; } /* We are going to modify some text, so let's prepare to undo it. */ rl_modifying (start, end); for (; start < end; start++) { switch (op) { case UpCase: the_line[start] = to_upper (the_line[start]); break; case DownCase: the_line[start] = to_lower (the_line[start]); break; case CapCase: if (state == 0) { the_line[start] = to_upper (the_line[start]); state = 1; } else { the_line[start] = to_lower (the_line[start]); } if (!pure_alphabetic (the_line[start])) state = 0; break; default: abort (); return -1; } } rl_point = end; return 0; } /* **************************************************************** */ /* */ /* Transposition */ /* */ /* **************************************************************** */ /* Transpose the words at point. */ rl_transpose_words (count, key) int count, key; { char *word1, *word2; int w1_beg, w1_end, w2_beg, w2_end; int orig_point = rl_point; if (!count) return 0; /* Find the two words. */ rl_forward_word (count); w2_end = rl_point; rl_backward_word (1); w2_beg = rl_point; rl_backward_word (count); w1_beg = rl_point; rl_forward_word (1); w1_end = rl_point; /* Do some check to make sure that there really are two words. */ if ((w1_beg == w2_beg) || (w2_beg < w1_end)) { ding (); rl_point = orig_point; return -1; } /* Get the text of the words. */ word1 = rl_copy_text (w1_beg, w1_end); word2 = rl_copy_text (w2_beg, w2_end); /* We are about to do many insertions and deletions. Remember them as one operation. */ rl_begin_undo_group (); /* Do the stuff at word2 first, so that we don't have to worry about word1 moving. */ rl_point = w2_beg; rl_delete_text (w2_beg, w2_end); rl_insert_text (word1); rl_point = w1_beg; rl_delete_text (w1_beg, w1_end); rl_insert_text (word2); /* This is exactly correct since the text before this point has not changed in length. */ rl_point = w2_end; /* I think that does it. */ rl_end_undo_group (); free (word1); free (word2); return 0; } /* Transpose the characters at point. If point is at the end of the line, then transpose the characters before point. */ rl_transpose_chars (count, key) int count, key; { char dummy[2]; if (!count) return 0; if (!rl_point || rl_end < 2) { ding (); return -1; } rl_begin_undo_group (); if (rl_point == rl_end) { --rl_point; count = 1; } rl_point--; dummy[0] = the_line[rl_point]; dummy[1] = '\0'; rl_delete_text (rl_point, rl_point + 1); rl_point += count; if (rl_point > rl_end) rl_point = rl_end; else if (rl_point < 0) rl_point = 0; rl_insert_text (dummy); rl_end_undo_group (); return 0; } /* **************************************************************** */ /* */ /* Undo, and Undoing */ /* */ /* **************************************************************** */ /* The current undo list for THE_LINE. */ UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL; /* Remember how to undo something. Concatenate some undos if that seems right. */ void rl_add_undo (what, start, end, text) enum undo_code what; int start, end; char *text; { UNDO_LIST *temp = (UNDO_LIST *)xmalloc (sizeof (UNDO_LIST)); temp->what = what; temp->start = start; temp->end = end; temp->text = text; temp->next = rl_undo_list; rl_undo_list = temp; } /* Free the existing undo list. */ void free_undo_list () { while (rl_undo_list) { UNDO_LIST *release = rl_undo_list; rl_undo_list = rl_undo_list->next; if (release->what == UNDO_DELETE) free (release->text); free (release); } rl_undo_list = (UNDO_LIST *)NULL; } /* Undo the next thing in the list. Return 0 if there is nothing to undo, or non-zero if there was. */ int rl_do_undo () { UNDO_LIST *release; int waiting_for_begin = 0; undo_thing: if (!rl_undo_list) return (0); doing_an_undo = 1; switch (rl_undo_list->what) { /* Undoing deletes means inserting some text. */ case UNDO_DELETE: rl_point = rl_undo_list->start; rl_insert_text (rl_undo_list->text); free (rl_undo_list->text); break; /* Undoing inserts means deleting some text. */ case UNDO_INSERT: rl_delete_text (rl_undo_list->start, rl_undo_list->end); rl_point = rl_undo_list->start; break; /* Undoing an END means undoing everything 'til we get to a BEGIN. */ case UNDO_END: waiting_for_begin++; break; /* Undoing a BEGIN means that we are done with this group. */ case UNDO_BEGIN: if (waiting_for_begin) waiting_for_begin--; else ding (); break; } doing_an_undo = 0; release = rl_undo_list; rl_undo_list = rl_undo_list->next; free (release); if (waiting_for_begin) goto undo_thing; return (1); } /* Begin a group. Subsequent undos are undone as an atomic operation. */ int rl_begin_undo_group () { rl_add_undo (UNDO_BEGIN, 0, 0, 0); return 0; } /* End an undo group started with rl_begin_undo_group (). */ int rl_end_undo_group () { rl_add_undo (UNDO_END, 0, 0, 0); return 0; } /* Save an undo entry for the text from START to END. */ rl_modifying (start, end) int start, end; { if (start > end) { int t = start; start = end; end = t; } if (start != end) { char *temp = rl_copy_text (start, end); rl_begin_undo_group (); rl_add_undo (UNDO_DELETE, start, end, temp); rl_add_undo (UNDO_INSERT, start, end, (char *)NULL); rl_end_undo_group (); } return 0; } /* Revert the current line to its previous state. */ int rl_revert_line (count, key) int count, key; { if (!rl_undo_list) ding (); else { while (rl_undo_list) rl_do_undo (); } return 0; } /* Do some undoing of things that were done. */ int rl_undo_command (count, key) int count, key; { if (count < 0) return 0; /* Nothing to do. */ while (count) { if (rl_do_undo ()) count--; else { ding (); break; } } return 0; } /* **************************************************************** */ /* */ /* History Utilities */ /* */ /* **************************************************************** */ /* We already have a history library, and that is what we use to control the history features of readline. However, this is our local interface to the history mechanism. */ /* While we are editing the history, this is the saved version of the original line. */ HIST_ENTRY *saved_line_for_history = (HIST_ENTRY *)NULL; /* Set the history pointer back to the last entry in the history. */ static void start_using_history () { using_history (); if (saved_line_for_history) _rl_free_history_entry (saved_line_for_history); saved_line_for_history = (HIST_ENTRY *)NULL; } /* Free the contents (and containing structure) of a HIST_ENTRY. */ void _rl_free_history_entry (entry) HIST_ENTRY *entry; { if (!entry) return; if (entry->line) free (entry->line); free (entry); } /* Perhaps put back the current line if it has changed. */ maybe_replace_line () { HIST_ENTRY *temp = current_history (); /* If the current line has changed, save the changes. */ if (temp && ((UNDO_LIST *)(temp->data) != rl_undo_list)) { temp = replace_history_entry (where_history (), the_line, rl_undo_list); free (temp->line); free (temp); } return 0; } /* Put back the saved_line_for_history if there is one. */ maybe_unsave_line () { if (saved_line_for_history) { int line_len; line_len = strlen (saved_line_for_history->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, saved_line_for_history->line); rl_undo_list = (UNDO_LIST *)saved_line_for_history->data; _rl_free_history_entry (saved_line_for_history); saved_line_for_history = (HIST_ENTRY *)NULL; rl_end = rl_point = strlen (the_line); } else ding (); return 0; } /* Save the current line in saved_line_for_history. */ maybe_save_line () { if (!saved_line_for_history) { saved_line_for_history = (HIST_ENTRY *)xmalloc (sizeof (HIST_ENTRY)); saved_line_for_history->line = savestring (the_line); saved_line_for_history->data = (char *)rl_undo_list; } return 0; } /* **************************************************************** */ /* */ /* History Commands */ /* */ /* **************************************************************** */ /* Meta-< goes to the start of the history. */ rl_beginning_of_history (count, key) int count, key; { return (rl_get_previous_history (1 + where_history ())); } /* Meta-> goes to the end of the history. (The current line). */ rl_end_of_history (count, key) int count, key; { maybe_replace_line (); using_history (); maybe_unsave_line (); return 0; } /* Move down to the next history line. */ rl_get_next_history (count, key) int count, key; { HIST_ENTRY *temp = (HIST_ENTRY *)NULL; if (count < 0) return (rl_get_previous_history (-count)); if (!count) return 0; maybe_replace_line (); while (count) { temp = next_history (); if (!temp) break; --count; } if (!temp) maybe_unsave_line (); else { int line_len; line_len = strlen (temp->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, temp->line); rl_undo_list = (UNDO_LIST *)temp->data; rl_end = rl_point = strlen (the_line); #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_point = 0; #endif /* VI_MODE */ } return 0; } /* Get the previous item out of our interactive history, making it the current line. If there is no previous history, just ding. */ rl_get_previous_history (count, key) int count, key; { HIST_ENTRY *old_temp = (HIST_ENTRY *)NULL; HIST_ENTRY *temp = (HIST_ENTRY *)NULL; if (count < 0) return (rl_get_next_history (-count)); if (!count) return 0; /* If we don't have a line saved, then save this one. */ maybe_save_line (); /* If the current line has changed, save the changes. */ maybe_replace_line (); while (count) { temp = previous_history (); if (!temp) break; else old_temp = temp; --count; } /* If there was a large argument, and we moved back to the start of the history, that is not an error. So use the last value found. */ if (!temp && old_temp) temp = old_temp; if (!temp) ding (); else { int line_len; line_len = strlen (temp->line); if (line_len >= rl_line_buffer_len) rl_extend_line_buffer (line_len); strcpy (the_line, temp->line); rl_undo_list = (UNDO_LIST *)temp->data; rl_end = rl_point = line_len; #if defined (VI_MODE) if (rl_editing_mode == vi_mode) rl_point = 0; #endif /* VI_MODE */ } return 0; } /* Make C be the next command to be executed. */ rl_execute_next (c) int c; { rl_pending_input = c; return 0; } /* **************************************************************** */ /* */ /* The Mark and the Region. */ /* */ /* **************************************************************** */ /* Set the mark at POSITION. */ rl_set_mark (position) int position; { if (position > rl_end) return -1; rl_mark = position; return 0; } /* Exchange the position of mark and point. */ rl_exchange_mark_and_point (count, key) int count, key; { if (rl_mark > rl_end) rl_mark = -1; if (rl_mark == -1) { ding (); return -1; } else { int temp = rl_point; rl_point = rl_mark; rl_mark = temp; } return 0; } /* **************************************************************** */ /* */ /* Killing Mechanism */ /* */ /* **************************************************************** */ /* What we assume for a max number of kills. */ #define DEFAULT_MAX_KILLS 10 /* The real variable to look at to find out when to flush kills. */ int rl_max_kills = DEFAULT_MAX_KILLS; /* Where to store killed text. */ char **rl_kill_ring = (char **)NULL; /* Where we are in the kill ring. */ int rl_kill_index = 0; /* How many slots we have in the kill ring. */ int rl_kill_ring_length = 0; /* How to say that you only want to save a certain amount of kill material. */ rl_set_retained_kills (num) int num; { return 0; } /* The way to kill something. This appends or prepends to the last kill, if the last command was a kill command. if FROM is less than TO, then the text is appended, otherwise prepended. If the last command was not a kill command, then a new slot is made for this kill. */ rl_kill_text (from, to) int from, to; { int slot; char *text; /* Is there anything to kill? */ if (from == to) { last_command_was_kill++; return 0; } text = rl_copy_text (from, to); /* Delete the copied text from the line. */ rl_delete_text (from, to); /* First, find the slot to work with. */ if (!last_command_was_kill) { /* Get a new slot. */ if (!rl_kill_ring) { /* If we don't have any defined, then make one. */ rl_kill_ring = (char **) xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *)); rl_kill_ring[slot = 0] = (char *)NULL; } else { /* We have to add a new slot on the end, unless we have exceeded the max limit for remembering kills. */ slot = rl_kill_ring_length; if (slot == rl_max_kills) { register int i; free (rl_kill_ring[0]); for (i = 0; i < slot; i++) rl_kill_ring[i] = rl_kill_ring[i + 1]; } else { slot = rl_kill_ring_length += 1; rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *)); } rl_kill_ring[--slot] = (char *)NULL; } } else slot = rl_kill_ring_length - 1; /* If the last command was a kill, prepend or append. */ if (last_command_was_kill && rl_editing_mode != vi_mode) { char *old = rl_kill_ring[slot]; char *new = xmalloc (1 + strlen (old) + strlen (text)); if (from < to) { strcpy (new, old); strcat (new, text); } else { strcpy (new, text); strcat (new, old); } free (old); free (text); rl_kill_ring[slot] = new; } else { rl_kill_ring[slot] = text; } rl_kill_index = slot; last_command_was_kill++; return 0; } /* Now REMEMBER! In order to do prepending or appending correctly, kill commands always make rl_point's original position be the FROM argument, and rl_point's extent be the TO argument. */ /* **************************************************************** */ /* */ /* Killing Commands */ /* */ /* **************************************************************** */ /* Delete the word at point, saving the text in the kill ring. */ rl_kill_word (count, key) int count, key; { int orig_point = rl_point; if (count < 0) return (rl_backward_kill_word (-count)); else { rl_forward_word (count); if (rl_point != orig_point) rl_kill_text (orig_point, rl_point); rl_point = orig_point; } return 0; } /* Rubout the word before point, placing it on the kill ring. */ rl_backward_kill_word (count, ignore) int count, ignore; { int orig_point = rl_point; if (count < 0) return (rl_kill_word (-count)); else { rl_backward_word (count); if (rl_point != orig_point) rl_kill_text (orig_point, rl_point); } return 0; } /* Kill from here to the end of the line. If DIRECTION is negative, kill back to the line start instead. */ rl_kill_line (direction, ignore) int direction, ignore; { int orig_point = rl_point; if (direction < 0) return (rl_backward_kill_line (1)); else { rl_end_of_line (); if (orig_point != rl_point) rl_kill_text (orig_point, rl_point); rl_point = orig_point; } return 0; } /* Kill backwards to the start of the line. If DIRECTION is negative, kill forwards to the line end instead. */ rl_backward_kill_line (direction, ignore) int direction, ignore; { int orig_point = rl_point; if (direction < 0) return (rl_kill_line (1)); else { if (!rl_point) ding (); else { rl_beg_of_line (); rl_kill_text (orig_point, rl_point); } } return 0; } /* Kill the whole line, no matter where point is. */ rl_kill_full_line (count, ignore) int count, ignore; { rl_begin_undo_group (); rl_point = 0; rl_kill_text (rl_point, rl_end); rl_end_undo_group (); return 0; } /* Yank back the last killed text. This ignores arguments. */ rl_yank (count, ignore) int count, ignore; { if (!rl_kill_ring) { rl_abort (); return -1; } rl_set_mark (rl_point); rl_insert_text (rl_kill_ring[rl_kill_index]); return 0; } /* If the last command was yank, or yank_pop, and the text just before point is identical to the current kill item, then delete that text from the line, rotate the index down, and yank back some other text. */ rl_yank_pop (count, key) int count, key; { int l; if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) || !rl_kill_ring) { rl_abort (); return -1; } l = strlen (rl_kill_ring[rl_kill_index]); if (((rl_point - l) >= 0) && (strncmp (the_line + (rl_point - l), rl_kill_ring[rl_kill_index], l) == 0)) { rl_delete_text ((rl_point - l), rl_point); rl_point -= l; rl_kill_index--; if (rl_kill_index < 0) rl_kill_index = rl_kill_ring_length - 1; rl_yank (1, 0); return 0; } else { rl_abort (); return -1; } } /* Yank the COUNTth argument from the previous history line. */ rl_yank_nth_arg (count, ignore) int count, ignore; { register HIST_ENTRY *entry = previous_history (); char *arg; if (entry) next_history (); else { ding (); return -1; } arg = history_arg_extract (count, count, entry->line); if (!arg || !*arg) { ding (); return -1; } rl_begin_undo_group (); #if defined (VI_MODE) /* Vi mode always inserts a space before yanking the argument, and it inserts it right *after* rl_point. */ if (rl_editing_mode == vi_mode) { rl_vi_append_mode (); rl_insert_text (" "); } #endif /* VI_MODE */ rl_insert_text (arg); free (arg); rl_end_undo_group (); return 0; } /* Yank the last argument from the previous history line. This `knows' how rl_yank_nth_arg treats a count of `$'. With an argument, this behaves the same as rl_yank_nth_arg. */ int rl_yank_last_arg (count, key) int count, key; { if (rl_explicit_arg) return (rl_yank_nth_arg (count, key)); else return (rl_yank_nth_arg ('$', key)); } /* How to toggle back and forth between editing modes. */ rl_vi_editing_mode (count, key) int count, key; { #if defined (VI_MODE) rl_editing_mode = vi_mode; rl_vi_insertion_mode (); return 0; #endif /* VI_MODE */ } rl_emacs_editing_mode (count, key) int count, key; { rl_editing_mode = emacs_mode; _rl_keymap = emacs_standard_keymap; return 0; } /* **************************************************************** */ /* */ /* USG (System V) Support */ /* */ /* **************************************************************** */ int rl_getc (stream) FILE *stream; { int result; unsigned char c; #if defined (__GO32__) if (isatty (0)) return (getkey () & 0x7F); #endif /* __GO32__ */ while (1) { result = read (fileno (stream), &c, sizeof (unsigned char)); if (result == sizeof (unsigned char)) return (c); /* If zero characters are returned, then the file that we are reading from is empty! Return EOF in that case. */ if (result == 0) return (EOF); #if defined (EWOULDBLOCK) if (errno == EWOULDBLOCK) { int flags; if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0) return (EOF); if (flags & O_NDELAY) { flags &= ~O_NDELAY; fcntl (fileno (stream), F_SETFL, flags); continue; } continue; } #endif /* EWOULDBLOCK */ #if defined (_POSIX_VERSION) && defined (EAGAIN) && defined (O_NONBLOCK) if (errno == EAGAIN) { int flags; if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0) return (EOF); if (flags & O_NONBLOCK) { flags &= ~O_NONBLOCK; fcntl (fileno (stream), F_SETFL, flags); continue; } } #endif /* _POSIX_VERSION && EAGAIN && O_NONBLOCK */ #if !defined (__GO32__) /* If the error that we received was SIGINT, then try again, this is simply an interrupted system call to read (). Otherwise, some error ocurred, also signifying EOF. */ if (errno != EINTR) return (EOF); #endif /* !__GO32__ */ } } #if !defined (SHELL) #ifdef savestring #undef savestring #endif /* Backwards compatibilty, now that savestring has been removed from all `public' readline header files. */ char * savestring (s) char *s; { return ((char *)strcpy (xmalloc (1 + (int)strlen (s)), (s))); } #endif /* Function equivalents for the macros defined in chartypes.h. */ #undef uppercase_p int uppercase_p (c) int c; { return (isupper (c)); } #undef lowercase_p int lowercase_p (c) int c; { return (islower (c)); } #undef pure_alphabetic int pure_alphabetic (c) int c; { return (isupper (c) || islower (c)); } #undef digit_p int digit_p (c) int c; { return (isdigit (c)); } #undef to_lower int to_lower (c) int c; { return (isupper (c) ? tolower (c) : c); } #undef to_upper int to_upper (c) int c; { return (islower (c) ? toupper (c) : c); } #undef digit_value int digit_value (c) int c; { return (isdigit (c) ? c - '0' : c); } #if defined (STATIC_MALLOC) /* **************************************************************** */ /* */ /* xmalloc and xrealloc () */ /* */ /* **************************************************************** */ static void memory_error_and_abort (); static char * xmalloc (bytes) int bytes; { char *temp = (char *)malloc (bytes); if (!temp) memory_error_and_abort (); return (temp); } static char * xrealloc (pointer, bytes) char *pointer; int bytes; { char *temp; if (!pointer) temp = (char *)malloc (bytes); else temp = (char *)realloc (pointer, bytes); if (!temp) memory_error_and_abort (); return (temp); } static void memory_error_and_abort () { fprintf (stderr, "readline: Out of virtual memory!\n"); abort (); } #endif /* STATIC_MALLOC */ /* **************************************************************** */ /* */ /* Testing Readline */ /* */ /* **************************************************************** */ #if defined (TEST) main () { HIST_ENTRY **history_list (); char *temp = (char *)NULL; char *prompt = "readline% "; int done = 0; while (!done) { temp = readline (prompt); /* Test for EOF. */ if (!temp) exit (1); /* If there is anything on the line, print it and remember it. */ if (*temp) { fprintf (stderr, "%s\r\n", temp); add_history (temp); } /* Check for `command' that we handle. */ if (strcmp (temp, "quit") == 0) done = 1; if (strcmp (temp, "list") == 0) { HIST_ENTRY **list = history_list (); register int i; if (list) { for (i = 0; list[i]; i++) { fprintf (stderr, "%d: %s\r\n", i, list[i]->line); free (list[i]->line); } free (list); } } free (temp); } } #endif /* TEST */ /* * Local variables: * compile-command: "gcc -g -traditional -I. -I.. -DTEST -o readline readline.c keymaps.o funmap.o history.o -ltermcap" * end: */ lafe/readline/rlconf.h100644 325 24 4037 6106101044 13132 0ustar dlduser/* rlconf.h -- readline configuration definitions */ /* Copyright (C) 1994 Free Software Foundation, Inc. This file contains the Readline Library (the Library), a set of routines for providing Emacs style line input to programs that ask for it. The Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. The Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is often shipped with GNU software, and is generally kept in a file called COPYING or LICENSE. If you do not have a copy of the license, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (_RLCONF_H_) #define _RLCONF_H_ /* Define this if you want the vi-mode editing available. */ #define VI_MODE /* Define this to get an indication of file type when listing completions. */ #define VISIBLE_STATS /* If defined, readline shows opening parens and braces when closing paren or brace entered. */ /* #define PAREN_MATCHING */ /* This definition is needed by readline.c, rltty.c, and signals.c. */ /* If on, then readline handles signals in a way that doesn't screw. */ #define HANDLE_SIGNALS /* Ugly but working hack for binding prefix meta. */ #define PREFIX_META_HACK /* The final, last-ditch effort file name for an init file. */ #define DEFAULT_INPUTRC "~/.inputrc" /* If defined, expand tabs to spaces. */ #define DISPLAY_TABS /* If defined, use the terminal escape sequence to move the cursor forward over a character when updating the line rather than rewriting it. */ /* #define HACK_TERMCAP_MOTION */ /* The string inserted by the vi-mode `insert comment' command. */ #define VI_COMMENT_BEGIN_DEFAULT "#" #endif /* _RLCONF_H_ */ lafe/readline/configure100755 325 24 104470 6106101044 13447 0ustar dlduser#!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 1.11 # Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. # This configure script is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as published # by the Free Software Foundation; either version 2, or (at your option) # any later version. # This script is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. echo CFLAGS = $CFLAGS # Save the original args to write them into config.status later. configure_args="$*" # Only options that might do something get documented. ac_usage="Usage: configure [options] [host] Options: [defaults in brackets after descriptions] --build=BUILD configure for building on BUILD [BUILD=HOST] --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --exec-prefix=PREFIX install host dependent files in PREFIX [/usr/local] --help print this message --host=HOST configure for HOST [guessed] --prefix=PREFIX install host independent files in PREFIX [/usr/local] --quiet, --silent do not print \`checking for...' messages --srcdir=DIR find the sources in DIR [configure dir or ..] --target=TARGET configure for TARGET [TARGET=HOST] --verbose print results of checks --version print the version of autoconf that created configure --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --x-includes=DIR X include files are in DIR --x-libraries=DIR X library files are in DIR" # Initialize some variables set by options. # The variables have the same names as the options, with # dashes changed to underlines. build=NONE exec_prefix= host=NONE no_create= nonopt=NONE norecursion= prefix= program_prefix= program_suffix= program_transform_name= silent= srcdir= target=NONE verbose= x_includes= x_libraries= ac_prev= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval "$ac_prev=\$ac_option" ac_prev= continue fi # Accept (but ignore some of) the important Cygnus configure # options, so we can diagnose typos. case "$ac_option" in -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) ac_optarg= ;; esac case "$ac_option" in -build | --build | --buil | --bui | --bu | --b) ac_prev=build ;; -build=* | --build=* | --buil=* | --bui=* | --bu=* | --b=*) build="$ac_optarg" ;; -disable-* | --disable-*) ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` eval "enable_${ac_feature}=no" ;; -enable-* | --enable-*) ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_feature: invalid feature name" >&2; exit 1 fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "enable_${ac_feature}='$ac_optarg'" ;; # For backward compatibility, recognize -exec-prefix and --exec_prefix. -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix="$ac_optarg" ;; -gas | --gas | --ga | --g) with_gas=yes ;; # Obsolete; use --with-gas. -help | --help | --hel | --he) cat << EOF $ac_usage EOF exit 0 ;; -host | --host | --hos | --ho) ac_prev=host ;; -host=* | --host=* | --hos=* | --ho=*) host="$ac_optarg" ;; -nfp | --nfp | --nf) with_fp=no ;; # Obsolete; use --without-fp. -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) norecursion=yes ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix="$ac_optarg" ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix="$ac_optarg" ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix="$ac_optarg" ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name="$ac_optarg" ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir="$ac_optarg" ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target="$ac_optarg" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers) echo "configure generated by autoconf version 1.11" exit 0 ;; -with-* | --with-*) ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "with_${ac_package}='$ac_optarg'" ;; -without-* | --without-*) ac_package=`echo $ac_option|sed -e 's/-*without-//'` # Reject names that aren't valid shell variable names. if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $ac_package: invalid package name" >&2; exit 1 fi ac_package=`echo $ac_package| sed 's/-/_/g'` eval "with_${ac_package}=no" ;; --x) with_x=yes ;; # Obsolete; use --with-x. -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes="$ac_optarg" ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries="$ac_optarg" ;; -*) echo "configure: $ac_option: invalid option; use --help to show usage" >&2; exit 1 ;; *) if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then echo "configure: warning: $ac_option: invalid host type" >&2 fi if test "x$nonopt" != xNONE; then echo "configure: can only configure for one host and one target at a time" >&2; exit 1 fi nonopt="$ac_option" ;; esac done if test -n "$ac_prev"; then echo "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" >&2; exit 1 fi trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 2 15 trap 'rm -fr confdefs* $ac_clean_files' 0 # Save the original args if we used an alternate arg parser. ac_configure_temp="${configure_args-$*}" # Strip out --no-create and --norecursion so they don't pile up. configure_args= for ac_arg in $ac_configure_temp; do case "$ac_arg" in -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) ;; -norecursion | --norecursion | --norecursio | --norecursi \ | --norecurs | --norecur | --norecu | --norec | --nore | --nor) ;; *) configure_args="$configure_args $ac_arg" ;; esac done # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set'; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set'; then LANG=C; export LANG; fi # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. ac_unique_file=readline.h # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then `..'. ac_prog=$0 ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. srcdir=$ac_confdir if test ! -r $srcdir/$ac_unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$ac_unique_file; then if test x$ac_srcdir_defaulted = xyes; then echo "configure: can not find sources in ${ac_confdir} or .." >&2; exit 1 else echo "configure: can not find sources in ${srcdir}" >&2; exit 1 fi fi ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='${CPP}' ac_compile='${CC-cc} $CFLAGS $LDFLAGS conftest.${ac_ext} -o conftest $LIBS >/dev/null 2>&1' echo CFLAGS=$CFLAGS ac_compile=$ac_compile #!/bin/sh # From configure.in Configure for Readline 2.0 # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g auto_cflags=1 echo CFLAGS = $CFLAGS if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set ac_dummy gcc; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then CC="gcc" break fi done IFS="$ac_save_ifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* # If we're using gcc and the user hasn't specified CFLAGS, add -O to CFLAGS. test -n "$GCC" && test -n "$auto_cflags" && CFLAGS="$CFLAGS -O" echo CFLAGS = $CFLAGS test -n "$silent" || echo "checking how to run the C preprocessor" if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.${ac_ext} < Syntax Error EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* fi test -n "$verbose" && echo " setting CPP to $CPP" if test -n "$GCC"; then test -n "$silent" || echo "checking whether -traditional is needed" ac_pattern="Autoconf.*'x'" ac_prog='#include Autoconf TIOCGETP' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* if test -z "$ac_need_trad"; then ac_prog='#include Autoconf TCGETA' cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "$ac_pattern" conftest.out >/dev/null 2>&1; then rm -rf conftest* ac_need_trad=1 fi rm -f conftest* fi test -n "$ac_need_trad" && CC="$CC -traditional" fi if test -z "$RANLIB"; then # Extract the first word of `ranlib', so it can be a program name with args. set ac_dummy ranlib; ac_word=$2 test -n "$silent" || echo "checking for $ac_word" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then RANLIB="ranlib" break fi done IFS="$ac_save_ifs" fi test -z "$RANLIB" && RANLIB=":" test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB" test -n "$silent" || echo "checking for BSD string and memory functions" cat > conftest.${ac_ext} < int main() { return 0; } int t() { rindex(0, 0); bzero(0, 0);; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining USG" echo "#define" USG "1" >> confdefs.h DEFS="$DEFS -DUSG=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}USG\${ac_dB}USG\${ac_dC}1\${ac_dD} \${ac_uA}USG\${ac_uB}USG\${ac_uC}1\${ac_uD} \${ac_eA}USG\${ac_eB}USG\${ac_eC}1\${ac_eD} " } fi rm -f conftest* for ac_func in strcasecmp sighold do ac_tr_func=HAVE_`echo $ac_func | tr '[a-z]' '[A-Z]'` test -n "$silent" || echo "checking for ${ac_func}" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${ac_func}) || defined (__stub___${ac_func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${ac_func}(); ${ac_func}(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_func}" echo "#define" ${ac_tr_func} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_func}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_func}\${ac_dB}${ac_tr_func}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_func}\${ac_uB}${ac_tr_func}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_func}\${ac_eB}${ac_tr_func}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done for ac_hdr in unistd.h stdlib.h varargs.h string.h alloca.h \ dirent.h sys/ptem.h sys/pte.h sys/stream.h termcap.h \ termio.h do ac_tr_hdr=HAVE_`echo $ac_hdr | tr '[a-z]./' '[A-Z]__'` test -n "$silent" || echo "checking for ${ac_hdr}" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${ac_tr_hdr}" echo "#define" ${ac_tr_hdr} "1" >> confdefs.h DEFS="$DEFS -D${ac_tr_hdr}=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}${ac_tr_hdr}\${ac_dB}${ac_tr_hdr}\${ac_dC}1\${ac_dD} \${ac_uA}${ac_tr_hdr}\${ac_uB}${ac_tr_hdr}\${ac_uC}1\${ac_uD} \${ac_eA}${ac_tr_hdr}\${ac_eB}${ac_tr_hdr}\${ac_eC}1\${ac_eD} " } fi rm -f conftest* done test -n "$silent" || echo "checking for sys/file.h" cat > conftest.${ac_ext} < EOF # Some shells (Coherent) do redirections in the wrong order, so need # the parens. ac_err=`eval "($ac_cpp conftest.${ac_ext} >/dev/null) 2>&1"` if test -z "$ac_err"; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining NO_SYS_FILE" echo "#define" NO_SYS_FILE "1" >> confdefs.h DEFS="$DEFS -DNO_SYS_FILE=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}NO_SYS_FILE\${ac_dB}NO_SYS_FILE\${ac_dC}1\${ac_dD} \${ac_uA}NO_SYS_FILE\${ac_uB}NO_SYS_FILE\${ac_uC}1\${ac_uD} \${ac_eA}NO_SYS_FILE\${ac_eB}NO_SYS_FILE\${ac_eC}1\${ac_eD} " } fi rm -f conftest* if test -z "$have_tiocgwinsz"; then test -n "$silent" || echo "checking for TIOCGWINSZ in sys/ioctl.h" cat > conftest.${ac_ext} < #include int main() { return 0; } int t() { int x = TIOCGWINSZ;; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining GWINSZ_IN_SYS_IOCTL" echo "#define" GWINSZ_IN_SYS_IOCTL "1" >> confdefs.h DEFS="$DEFS -DGWINSZ_IN_SYS_IOCTL=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}GWINSZ_IN_SYS_IOCTL\${ac_dB}GWINSZ_IN_SYS_IOCTL\${ac_dC}1\${ac_dD} \${ac_uA}GWINSZ_IN_SYS_IOCTL\${ac_uB}GWINSZ_IN_SYS_IOCTL\${ac_uC}1\${ac_uD} \${ac_eA}GWINSZ_IN_SYS_IOCTL\${ac_eB}GWINSZ_IN_SYS_IOCTL\${ac_eC}1\${ac_eD} " } fi rm -f conftest* fi test -n "$silent" || echo "checking for programs able to redeclare getpw functions" cat > conftest.${ac_ext} < #include extern struct passwd *getpwuid(); int main() { return 0; } int t() { struct passwd *z; z = getpwuid(0);; return 0; } EOF if eval $ac_compile; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_GETPW_DECLS" echo "#define" HAVE_GETPW_DECLS "1" >> confdefs.h DEFS="$DEFS -DHAVE_GETPW_DECLS=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_GETPW_DECLS\${ac_dB}HAVE_GETPW_DECLS\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_GETPW_DECLS\${ac_uB}HAVE_GETPW_DECLS\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_GETPW_DECLS\${ac_eB}HAVE_GETPW_DECLS\${ac_eC}1\${ac_eD} " } fi rm -f conftest* # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! test -n "$silent" || echo "checking for working alloca.h" cat > conftest.${ac_ext} < int main() { return 0; } int t() { char *p = alloca(2 * sizeof(int));; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define" HAVE_ALLOCA_H "1" >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA_H\${ac_dB}HAVE_ALLOCA_H\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA_H\${ac_uB}HAVE_ALLOCA_H\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA_H\${ac_eB}HAVE_ALLOCA_H\${ac_eC}1\${ac_eD} " } fi rm -f conftest* ac_decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " test -n "$silent" || echo "checking for alloca" cat > conftest.${ac_ext} <> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}HAVE_ALLOCA\${ac_dB}HAVE_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}HAVE_ALLOCA\${ac_uB}HAVE_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}HAVE_ALLOCA\${ac_eB}HAVE_ALLOCA\${ac_eC}1\${ac_eD} " } else rm -rf conftest* ac_alloca_missing=1 cat > conftest.${ac_ext} < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then rm -rf conftest* test -n "$silent" || echo "checking for _getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "_getb67" echo "#define" CRAY_STACKSEG_END "_getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}_getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}_getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}_getb67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for GETB67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "GETB67" echo "#define" CRAY_STACKSEG_END "GETB67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}GETB67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}GETB67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}GETB67\${ac_eD} " } else rm -rf conftest* test -n "$silent" || echo "checking for getb67" cat > conftest.${ac_ext} < int main() { return 0; } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif ; return 0; } EOF if eval $ac_compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining" CRAY_STACKSEG_END to be "getb67" echo "#define" CRAY_STACKSEG_END "getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" ac_sed_defs="${ac_sed_defs}\${ac_dA}CRAY_STACKSEG_END\${ac_dB}CRAY_STACKSEG_END\${ac_dC}getb67\${ac_dD} \${ac_uA}CRAY_STACKSEG_END\${ac_uB}CRAY_STACKSEG_END\${ac_uC}getb67\${ac_uD} \${ac_eA}CRAY_STACKSEG_END\${ac_eB}CRAY_STACKSEG_END\${ac_eC}getb67\${ac_eD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$ac_alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define" C_ALLOCA "1" >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}C_ALLOCA\${ac_dB}C_ALLOCA\${ac_dC}1\${ac_dD} \${ac_uA}C_ALLOCA\${ac_uB}C_ALLOCA\${ac_uC}1\${ac_uD} \${ac_eA}C_ALLOCA\${ac_eB}C_ALLOCA\${ac_eC}1\${ac_eD} " } test -n "$silent" || echo "checking stack direction for C alloca" test -n "$silent" || echo "checking whether cross-compiling" # If we cannot run a trivial program, we must be cross compiling. cat > conftest.${ac_ext} </dev/null; then : else cross_compiling=1 fi rm -fr conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "0" echo "#define" STACK_DIRECTION "0" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}0\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}0\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}0\${ac_eD} " } else cat > conftest.${ac_ext} < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $ac_compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "1" echo "#define" STACK_DIRECTION "1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}1\${ac_eD} " } else { test -n "$verbose" && \ echo " defining" STACK_DIRECTION to be "-1" echo "#define" STACK_DIRECTION "-1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" ac_sed_defs="${ac_sed_defs}\${ac_dA}STACK_DIRECTION\${ac_dB}STACK_DIRECTION\${ac_dC}-1\${ac_dD} \${ac_uA}STACK_DIRECTION\${ac_uB}STACK_DIRECTION\${ac_uC}-1\${ac_uD} \${ac_eA}STACK_DIRECTION\${ac_eB}STACK_DIRECTION\${ac_eC}-1\${ac_eD} " } fi fi rm -fr conftest* fi # The preferred way to propogate these variables is regular @ substitutions. if test -n "$prefix"; then ac_prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" else prefix=/usr/local fi if test -n "$exec_prefix"; then ac_prsub="$ac_prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" else exec_prefix='${prefix}' # Let make expand it. fi # Any assignment to VPATH causes Sun make to only execute # the first set of double-colon rules, so remove it if not needed. # If there is a colon in the path, we need to keep it. if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args ac_cs_usage="Usage: config.status [--recheck] [--version] [--help]" for ac_option do case "\$ac_option" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args --no-create ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "config.status generated by autoconf version 1.11" exit 0 ;; -help | --help | --hel | --he | --h) echo "\$ac_cs_usage"; exit 0 ;; *) echo "\$ac_cs_usage"; exit 1 ;; esac done trap 'rm -fr Makefile config.h conftest*; exit 1' 1 2 15 CC='$CC' CFLAGS='$CFLAGS' LDFLAGS='$LDFLAGS' CPP='$CPP' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' RANLIB='$RANLIB' ALLOCA='$ALLOCA' LIBS='$LIBS' srcdir='$srcdir' top_srcdir='$top_srcdir' prefix='$prefix' exec_prefix='$exec_prefix' ac_prsub='$ac_prsub' ac_vpsub='$ac_vpsub' extrasub='$extrasub' EOF echo CFLAGS = $CFLAGS cat >> config.status <<\EOF ac_given_srcdir=$srcdir CONFIG_FILES=${CONFIG_FILES-"Makefile"} for ac_file in .. ${CONFIG_FILES}; do if test "x$ac_file" != x..; then # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" ac_dir_suffix="/$ac_dir" else ac_dir_suffix= fi # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dir_suffix"; then top_srcdir=. else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; *) # Relative path. srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" top_srcdir="$ac_dots$ac_given_srcdir" ;; esac echo creating "$ac_file" rm -f "$ac_file" comment_str="Generated automatically from `echo $ac_file|sed 's|.*/||'`.in by configure." case "$ac_file" in *.c | *.h | *.C | *.cc | *.m ) echo "/* $comment_str */" > "$ac_file" ;; * ) echo "# $comment_str" > "$ac_file" ;; esac sed -e " $ac_prsub $ac_vpsub $extrasub s%@CC@%$CC%g s%@CFLAGS@%$CFLAGS%g s%@LDFLAGS@%$LDFLAGS%g s%@CPP@%$CPP%g s%@INSTALL@%$INSTALL%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@RANLIB@%$RANLIB%g s%@ALLOCA@%$ALLOCA%g s%@LIBS@%$LIBS%g s%@srcdir@%$srcdir%g s%@top_srcdir@%$top_srcdir%g s%@prefix@%$prefix%g s%@exec_prefix@%$exec_prefix%g s%@DEFS@%-DHAVE_CONFIG_H%" $ac_given_srcdir/${ac_file}.in >> $ac_file fi; done # These sed commands are put into ac_sed_defs when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # Hopefully no one uses "!" as a variable value. # Other candidates for the sed separators, like , and @, do get used. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s!^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='\([ ][ ]*\)[^ ]*!\1#\2' ac_dC='\3' ac_dD='!g' # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_uA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='\([ ]\)!\1#\2define\3' ac_uC=' ' ac_uD='\4!g' # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_eA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_eB='$!\1#\2define\3' ac_eC=' ' ac_eD='!g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -9. sed 1,${ac_max_sh_lines}d conftest.sh > conftest.s2 # Like tail +10. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # config.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. ac_max_sed_lines=20 CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"} for ac_file in .. ${CONFIG_HEADERS}; do if test "x$ac_file" != x..; then echo CFLAGS = $CFLAGS echo creating $ac_file cp $ac_given_srcdir/$ac_file.in conftest.h1 cp conftest.sed conftest.stm while : do ac_lines=`grep -c . conftest.stm` if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${ac_max_sed_lines}q conftest.stm > conftest.s1 # Like head -20. sed 1,${ac_max_sed_lines}d conftest.stm > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.stm mv conftest.h2 conftest.h1 mv conftest.s2 conftest.stm done rm -f conftest.stm conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $ac_file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. echo "$ac_file is unchanged" rm -f conftest.h else rm -f $ac_file mv conftest.h $ac_file fi fi; done rm -f conftest.sed # Makefile uses this timestamp file to record whether config.h is up to date. touch stamp-config exit 0 EOF chmod +x config.status # Some shells look in PATH for config.status without the "./". test -n "$no_create" || ${CONFIG_SHELL-/bin/sh} ./config.status