eif000755 002123 000322 00000000000 05745514331 012766 5ustar00childrenpstaff000001 3016367 eif/BUGS000644 002123 000322 00000000676 05023465066 013524 0ustar00childrenpstaff000001 3016400 CURRENT BUGS: - There is a problem with connections over VERY slow links. It has to do with timing out on the connection. It has even shown up as the dreaded nuke bug, for other reasons. EIF may be more susceptable to the nuke bug than emp_client. The only problem is that you need a slow link to debug it. - When you hit ^C, weird output may occur from the client, until things sort themselves out. eif/CHANGES000644 002123 000322 00000002754 05745513351 014036 0ustar00childrenpstaff000001 3016401 Jun 6 1991 Added a runtime option to disable "^G" in the output. Prevents the terminal from beeping repetively when doing zillions of "fire"s, or other things like that. May 30 1991 Fixed a bunch of little things to do with echoing the command line into a redirected file. This is necessary for many empire tools which use the first line to figure out what the rest of the data file is. This worked originally, but in cleaning up the code, broke it. Stupid. Shouldn't screw so much with working code. May 30 1991 Fixed "^C" so that it will abort the current command. Was unable to abort telegrams and announcements. Not sure when this problem developed, but pretty sure it worked at one time previously. May 30 1991 Telegrams and announcements can now have ";" in them. This means that you can't do: tele 2 ; Hi there ; . You now have to type each line explicitly. ----------- Version 1.0.2 ------------ Jan 1994 Jim Gillogly Fixed the "kill" command in expect.c. 26 May 1994 Ken Stevens removed the -g option in Makefile to make the executable smaller. 26 May 1994 Ken Stevens added a #define option "FUNNY_HIGH" in print.c. If highlighting isn't working on your terminal, then #define FUNNY_HIGH in print.c. ----------- Version 1.0.3 ------------------ 19 Apr 1995 Drake Diedrich Ported to DEC/OSF1 (Alpha). Removed some conflicting function definitions (sprintf ...) Replaced readline with readline-2.0. eif/alias.c000644 002123 000322 00000011154 05015000406 014247 0ustar00childrenpstaff000001 3011162 /************************************************************* * $Id: alias.c,v 1.4 91/05/17 12:10:28 dhay Exp $ * * alias.c * * Maintain the user aliases. * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include void prt(); void eprt(); typedef struct { char *alias; char *command; char mark; } alias_t; static alias_t *alias_list; static int numaliases = 0; static int maxaliases = 0; char *calloc(), *malloc(); /*********************************** * clear_alias_marks * * Clear the alias marks so they can be reused. */ void clear_alias_marks() { alias_t *ap; int i; for (ap=alias_list,i=0; (ap && i mark = 0; } /*********************************** * find_alias_loc * * Find the matching alias, if it exists. */ static alias_t * find_alias_loc(buf) char *buf; { alias_t *ap; int i; for (ap=alias_list,i=0; ap && ialias && !strcmp(ap->alias, buf)) return(ap); } return((alias_t *) 0); } /*********************************** * find_alias * * Find the alias, if it exists, and return a * pointer to it's command, if it hasn't been * marked as being used before. */ char * find_alias(buf) char *buf; { alias_t *ap; if ((ap=find_alias_loc(buf)) && !ap->mark) { ap->mark = 1; return(ap->command); } return((char *) 0); } /*********************************** * cmd_alias * * The alias command. */ void cmd_alias(alias, sub) char *alias; int sub; { char *command, *cp, *strcpy(); alias_t *ap; int i; /* Skip over trailing space. */ while(isspace(*alias)) alias++; /* If no alias is specified, print all the aliases. */ if (!*alias) { if (!numaliases) prt("No aliases defined.\n"); else for (ap=alias_list,i=0; ap&&ialias, ap->command); return; } command = alias; while (*command && !isspace(*command)) command++; if (*command) { *command++ = '\0'; while (isspace(*command)) command++; /* String "'s from the command */ if ('\"' == *command) { cp = ++command; while (*cp && '\"' != *cp) cp++; if ('\"' == *cp) *cp = '\0'; } } /* We prevent certain keywords from being aliased. */ /* Like, alias, unalias */ if (!strcmp(alias, "alias") || !strcmp(alias, "unalias")) { eprt("Too dangerous to allow that\n"); return; } /* If we find a matching alias, either print it or replace it. */ if ((ap=find_alias_loc(alias))) { if (*command) { (void)free(ap->command); } else { prt("alias %s \"%s\"\n", ap->alias, ap->command); return; } } else { if (!*command) { prt("%s undefined.\n", alias); return; } numaliases++; if (numaliases >= maxaliases) { alias_t *tp; maxaliases += 10; if (!(tp = (alias_t *) calloc((unsigned) maxaliases, sizeof(alias_t)))) exit(1); if (alias_list) bcopy((char *) alias_list, (char *) tp, ((numaliases-1) * sizeof(alias_t))); (void)free((char *)alias_list); alias_list = tp; } ap = &alias_list[numaliases - 1]; i = strlen(alias); ap->alias = malloc((unsigned)i+1); (void)strcpy(ap->alias, alias); } i = strlen(command); ap->command = malloc((unsigned)i+1); (void)strcpy(ap->command, command); return; } /*********************************** * cmd_unalias * * The unalias command. */ void cmd_unalias(buf, sub) char *buf; int sub; { char *alias, *cp; alias_t *ap, *bp; int i; alias = buf; /* Skip over trailing space. */ while (isspace(*alias)) alias++; if (!alias) { eprt("Expecting alias to remove.\n"); return; } cp = alias; while (!isspace(*cp)) cp++; *cp = '\0'; if ('*' == *alias && !*(alias+1)) { for (ap=alias_list,i=0; (ap && i alias); (void)free(ap->command); ap->alias = (char *) 0; } numaliases = 0; prt("All aliases removed.\n"); return; } if(!(ap = find_alias_loc(alias))) { eprt("Alias '%s' not found.\n", alias); return; } (void)free(ap->alias); (void)free(ap->command); bp = ap++; while (ap->alias) { bp->alias = ap->alias; bp->command = ap->command; bp = ap++; } bp->alias = (char *) 0; prt("Alias '%s' deleted.\n", alias); numaliases--; return; } eif/cntl.h000644 002123 000322 00000002324 05015000277 014134 0ustar00childrenpstaff000001 3012750 /************************************************************* * $Id: cntl.h,v 1.5 91/05/17 12:11:17 dhay Exp $ * * cntl.h * * This file describes some general data structures. * * See init.c for initial values. * */ /******************************************************* * Copyright (C) Doug Hay, 1989,90,91. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #ifndef CNTLH #define CNTLH typedef unsigned char flag_t; /************************** * Startup options. */ typedef struct { flag_t readstartup; char startupf[40]; } startup_opt_struct; /************************** * User info from passwd file. */ typedef struct { int uid; char *name; char *homedir; char *shell; } user_info_struct; /************************** * The global control structure. * * Where all the global control flags live. * * See init.c for default values. */ typedef struct { char *pname; /* Program name as passed in arg0 */ int argc; char **argv; int pid; startup_opt_struct st; user_info_struct usr; } control_struct; #endif CNTLH eif/compick.c000644 002123 000322 00000010145 05015000407 014607 0ustar00childrenpstaff000001 3011760 /************************************************************* * $Id: compick.c,v 1.6 91/05/17 12:10:47 dhay Exp $ * * compick.c * * Pick a command, any command. */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include /* In print.c */ void prt(), eprt(); /* In alias.c */ void cmd_alias(); void cmd_unalias(); /* In vars.c */ void cmd_setvar(); void cmd_unsetvar(); /* In gencoms.c */ void cmd_echo(); void cmd_beep(); void cmd_games(); void cmd_history(); void cmd_system(); /* In getcom.c */ void cmd_exec(); void cmd_if(); /* In empcon.c */ void cmd_connect(); void cmd_try(); void cmd_addgame(); /* Local to this file */ static void cmd_list(); typedef struct { void (*proc)(); /* The command procedure */ char *com; /* The command string */ int minlen; /* Min length to match, all if 0. */ int subcmdno; /* Sub type to pass to procedure */ char *help; /* Minor help string about command */ } com_t; #define NOP ((void (*)()) 0) #define EOLIST ((void (*)()) -1) #define QUIT ((void (*)()) -2) #define FUL -1 static com_t coms[] = { {cmd_alias, "alias", 0, 0, "Set or show command aliases."}, {cmd_unalias, "unalias", 0, 0, "Clear a single alias, or all aliases '*'."}, {cmd_echo, "echo", 0, 0, "Echo some stuff."}, {cmd_beep, "beep", 0, 0, "Send a Beep or ^G to the terminal."}, {cmd_games, "games", 0, 0, "List the possible games."}, {cmd_addgame, "addgame", 0, 0, "Add a game to the games list."}, {cmd_connect, "connect", 4, 0, "Connect "}, {cmd_connect, "kill", 0, 1, "kill - Try to kill a hung pid"}, {cmd_try, "try", 0, 0, "Try "}, {cmd_try, "trykill", 0, 1, "Trykill - same as kill"}, #ifndef lint {QUIT, "exit", 0, 0, "Quit the program."}, #endif {cmd_list, "cmdlist", 0, 0, "List all the EIF commands."}, {cmd_exec, "exec", 2, 0, "Read commands from a file."}, {cmd_exec, "runfeed", 2, 1, "Execute a program, and use output as commands."}, {cmd_history, "history", 0, 0, "Display the history."}, {cmd_setvar, "setvar", 0, 0, "Set a variable"}, {cmd_unsetvar, "unsetvar", 0, 0, "Unset a variable"}, {cmd_system, "@", 0, 0, "Pass the command off to the system to execute"}, {cmd_if, "if", 0, 0, "Uses /bin/test and stops at endif"}, {cmd_if, "elseif", 0, 1, "Next case in an 'if' sequence."}, {cmd_if, "else", 0, 2, "Last case in an 'if' sequence."}, {cmd_if, "endif", 0, 3, "Ends an 'if' sequence."}, #ifndef lint {EOLIST, "", 0, 0, ""} #endif }; /************************************ * direct_command * * Returns 1 if found and tried a command. * Returns 0 if couldn't find the command. */ int direct_command(buf) char *buf; { com_t *ct, *ft; int l=0, m=0; char hold[100]; while (isspace(*buf)) buf++; if (*buf && !isalnum(*buf)) { hold[l++] = *buf++; } else { while (*buf && isalnum(*buf) && (l < (sizeof(hold)-2))) hold[l++] = *buf++; } hold[l] = '\0'; if (!l) return(0); ft = (com_t *) 0; for (ct=coms; ct->proc != EOLIST; ct++) { m = 0; if (!ct->minlen) { if (strlen(ct->com) == l) m = (strcmp(ct->com, hold) == 0); } else if (ct->minlen <= l) m = (strncmp(ct->com, hold, l) == 0); if (m && ft) { eprt("Command '%s' ambiguous. More than one match.\n", hold); return(1); } if (m && !ft) ft = ct; } if (ft) { if (NOP == ft->proc) { prt("Sorry, command `%s' not implemented yet.\n", ft->com); } else if (QUIT == ft->proc) { eprt("Quitting....\n"); exit(0); } else { (ft->proc)(buf, ft->subcmdno); } return(1); } return(0); } /************************************ * cmd_list * * List the commands available. */ static void cmd_list(buf, sub) char *buf; int sub; { com_t *ct; for (ct=coms; ct->proc != EOLIST; ct++) { prt("%10s : %s\n", ct->com, ct->help); } } eif/data.h000644 002123 000322 00000002771 05015000277 014120 0ustar00childrenpstaff000001 3011765 /************************************************************* * $Id: data.h,v 1.4 91/05/17 12:11:37 dhay Exp $ * * data.h * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #ifndef DATAH #define DATAH #ifdef MAIN #define vext #define initint(name, val) int name = val #define initany(type, name, val) type name = val #else #define vext extern #define initint(name, val) extern int name #define initany(type, name, val) extern type name #endif initint(curout_isapipe, 0); initany(FILE, *curout, stdout); /* The global flags */ vext control_struct cntl; /* The current game */ initint(game_number, -1); /* The number of the current game */ initint(game_socket, -1); /* Socket of the current game */ initint(game_time, 0); /* Connect time of current game */ initint(game_btus, 0); /* BTU's of current game */ vext char game_name[20]; /* Name of current game */ vext char game_host[40]; vext char game_port[8]; vext char game_country[20]; vext char game_rep[10]; initint(game_wait, 120); /* Seconds to wait in read for data */ vext int game_xsize, game_ysize; vext int game_protocol; vext char game_dataf[50]; vext int Interrupt; /* True if we got a sig_int */ vext int Pipe_Interrupt; /* True if we got a sig_pipe */ #undef vext #endif DATAH eif/eif.c000644 002123 000322 00000007317 05745302202 013742 0ustar00childrenpstaff000001 3010660 /************************************************************* * $Id: eif.c,v 1.9 91/06/06 13:35:11 dhay Exp $ * * eif.c * * This is where things actually get done after runtime * commandline parsing. * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include #include "cntl.h" #include "data.h" /* In print.c */ void prt(), eprt(), notstdio_prt(); FILE *output_curout(); /* In getcom.c */ void cmd_exec(); int get_main_input(), get_input(); /* In compick.c */ int direct_command(); /* In connect/sock.c */ void writesock(); int readsock(); /* In empcon.c */ void game_died(); /* GNU readline stuff */ int rl_unbind_key(), stifle_history(); static void eif_sigdebug(); static void eif_interrupt(); static void eif_pipe(); static void commandloop(); static void send_command(); static char cmdbuf[300]; /************************************* * eif_away * * The main routine. */ void eif_away() { /* Stuff for the readline. */ rl_unbind_key(17); rl_unbind_key(19); /* initialize signal handling */ (void) signal(SIGQUIT, eif_sigdebug); /*Debugging*/ (void) signal(SIGALRM, SIG_IGN); (void) signal(SIGPIPE, eif_pipe); (void) signal(SIGINT, eif_interrupt); /* We want ^C to abort system calls. */ /* (void) siginterrupt(SIGINT, 1); */ prt("\nWelcome to EIF\n"); prt("Empire interface Version 1.0.2\n\n"); /* The problem with this is that the file is not actually * executed here. It is executed in the commandloop(). * This just sets it up for input as an exec file. */ if (cntl.st.readstartup) { cmd_exec(cntl.st.startupf, 2); } /* Only allow up to 100 commands in history */ stifle_history(100); while (1) commandloop(); } static void eif_sigdebug() { eprt("Intr\n"); } static void eif_pipe() { Pipe_Interrupt++; } static void eif_interrupt() { eprt("Intr\n"); Interrupt++; } /******************************************* * commandloop */ static void commandloop() { char prompt[20]; int echoed; while (1) { /* Design a prompt */ if (-1 == game_socket) { (void) strcpy(prompt, "Local% "); } else (void) sprintf(prompt, "\n%s [%d,%d]%% ", game_name, game_time, game_btus); /* Get the next command. */ echoed = get_main_input(cmdbuf, sizeof(cmdbuf), prompt); /* Is it a local command. */ if (!direct_command(cmdbuf)) { /* Are we connected to a game? */ if (-1 != game_socket) { /* redirected emp_player commands get the commandline as * their first line. Various tools depend on this. */ if (!echoed) notstdio_prt("%s\n", cmdbuf); send_command(cmdbuf); } else { if (cmdbuf[0]) { /* Well, should say something. */ eprt("Not a local command, and not connected to a game.\n"); } } } } } /******************************************* * send_command */ static void send_command(cmd) char *cmd; { int t; char prompt[200]; /* Are we connected to a game? */ if (-1 == game_socket) return; /* Send command to game */ writesock(game_socket, cmd); /* Read from game until a prompt returns. */ while ((t=readsock(game_socket, output_curout(), game_wait, prompt, sizeof(prompt))) == 2) { if (get_input(cmdbuf, sizeof(cmdbuf), prompt)) { writesock(game_socket, cmdbuf); } else writesock(game_socket, "\naborted"); } /* Damn, connection bit it. */ if (-1 == t) game_died(); } eif/empcon.c000644 002123 000322 00000011674 05015000407 014445 0ustar00childrenpstaff000001 3010710 /************************************************************* * $Id: empcon.c,v 1.5 91/05/17 12:10:50 dhay Exp $ * * empcon.c * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include "cntl.h" #include "data.h" #include /* In print.c */ void prt(), eprt(); /* In games.c */ void game_died(), switch_gameout(); int switch_to(), add_game(); /* In connect/connect.c */ int empire_connect(); /* In connect/sock.c */ int readsock(); /* Local */ static char *next_online(); /****************************************** * cmd_connect */ void cmd_connect(buf, sub) char *buf; int sub; { int kill_it=0; int sock; char nameb[20]; /* We are doing a kill, rather than a connect */ if (sub == 1) kill_it = 1; /* Parse or ask for the game name */ if (!next_online(buf, nameb, sizeof(nameb), "Game name? ", "Bad game name.")) return; /* Switch into that game's context. */ if (!switch_to(nameb)) return; /* If we aren't already connected */ if (-1 == game_socket) { if ((sock=empire_connect(game_host, game_port, game_country, game_rep, kill_it)) != -1) { eprt("Connected!\n"); game_socket = sock; game_time = 0; game_btus = 0; if (-1 == readsock(sock, stdout, 20, (char *) 0, 0)) game_died(); } else { if (!kill_it) eprt("Connection failed.\n"); game_died(); } } else eprt("Reconnected.\n"); } /****************************************** * cmd_try */ void cmd_try(buf, sub) char *buf; int sub; { int kill_it = 0; int sock; char nameb[20]; char coun[20]; char rep[20]; if (sub == 1) kill_it = 1; if (!(buf=next_online(buf, nameb, sizeof(nameb), "Game name? ", "Bad game name."))) return; if (!switch_to(nameb)) return; if (!(buf=next_online(buf, coun, sizeof(coun), "Country? ", "Bad country."))) return; if (!(buf=next_online(buf, rep, sizeof(rep), "Rep? ", "Bad rep."))) return; /* Make sure close an existing connection */ if (-1 != game_socket) { close(game_socket); game_socket = -1; } /* Try it. */ if ((sock=empire_connect(game_host, game_port, coun, rep, kill_it)) != -1) { eprt("Connected!\n"); game_socket = sock; game_time = 0; game_btus = 0; if (-1 == readsock(sock, stdout, 20, (char *) 0, 0)) game_died(); } else { if (!kill_it) eprt("Connection failed.\n"); game_died(); } } /****************************************** * game_died */ void game_died() { void switch_gameout(); if (-1 != game_socket) { eprt("Game died.\n"); close(game_socket); game_socket = -1; switch_gameout(); } } /****************************************** * next_online * * Parse a command line for an option, and if it * doesn't exist, ask the user for it. * * Allows quoted strings. */ static char * next_online(cmd, where, len, prompt, erm) char *cmd, *where, *prompt, *erm; int len; { char *cp; char *strcpy(); while (isspace(*cmd)) cmd++; if (*cmd) { cp = cmd; if ('"' == *cp) { cp++; while (*cmd && '"' != *cmd) cmd++; if ('"' != *cmd) { eprt("Missing end \". %s\n", erm); return((char *) 0); } } else while (*cmd && !isspace(*cmd)) cmd++; if (*cmd) *cmd++ = '\0'; if (strlen(cp) >= len) { eprt("Too long. %s\n", erm); return((char *) 0); } (void)strcpy(where, cp); } else { if (!get_input(where, len, prompt)) return((char *) 0); if (!*where) { eprt("%s\n", erm); return((char *) 0); } } return(cmd); } /****************************************** * cmd_addgame */ void cmd_addgame(cmd, sub) char *cmd; int sub; { char nameb[20], hostb[40], portb[8], counb[20], repb[10], datafb[50]; int xsize, ysize, proto, wait; if (!(cmd=next_online(cmd, nameb, sizeof(nameb), "Game name? ", "Bad game name."))) return; if (!(cmd=next_online(cmd, hostb, sizeof(hostb), "Host name or address? ", "Bad host name."))) return; if (!(cmd=next_online(cmd, portb, sizeof(portb), "Game port? ", "Bad game port."))) return; if (!(cmd=next_online(cmd, counb, sizeof(counb), "Country name? ", "Bad country name."))) return; if (!(cmd=next_online(cmd, repb, sizeof(repb), "Representative? ", "Bad representative."))) return; if (!(cmd=next_online(cmd, datafb, sizeof(datafb), "Data file name? ", "Bad datafile name."))) return; /* Currently, the only useful option is wait. */ xsize = 64; ysize = 32; proto = 1; wait = 120; if (!add_game(nameb, hostb, portb, counb, repb, xsize, ysize, proto, wait, datafb)) { eprt("Add of country failed.\n"); } else prt("Game %s added.\n", nameb); } eif/games.c000644 002123 000322 00000014067 05015000410 014256 0ustar00childrenpstaff000001 3010760 /************************************************************* * $Id: games.c,v 1.5 91/05/17 12:10:51 dhay Exp $ * * games.c * * Manage the games configured. */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include "cntl.h" #include "data.h" #include void prt(), eprt(); extern int errno; #define MAX_GAMES 50 typedef struct { char name[20]; /* The local name */ char host[40]; /* The host id, name or internet id. */ char port[8]; /* Ascii of the port */ char country[20]; /* The name of the country */ char rep[10]; /* The password into the country */ int protocol; /* Which version of the game */ int xsize, ysize; /* World dimensions */ int waittime; /* Waiting time is seconds for data */ char datafile[50]; /* Where game data is stored. */ } game_data_t; typedef struct { game_data_t dt; /* The above structure */ int socket; /* If <> 0 and <> -1, the open socket to game */ int time, btus; } game_t; game_t games[MAX_GAMES]; /************************************* * list_games * * Telling the user what the games are configured. */ void list_games(gam) char *gam; { int printed = 0; int i; game_t *gt; for (gt=games,i=0; idt.name[0] && (!gam || !*gam || !strcmp(gam, gt->dt.name))) { printed++; if (game_number == i) { if (gt->socket > 0) { prt("Game '%s', Current game, ** Connected\n", gt->dt.name); } else prt("Game '%s', Current game\n", gt->dt.name); } else { if (gt->socket > 0) { prt("Game '%s', ** Connected\n", gt->dt.name); } else prt("Game '%s'\n", gt->dt.name); } prt(" Host: %-20s Port: %-5s Coun: %s\n", gt->dt.host, gt->dt.port, gt->dt.country); prt(" World is %d by %d, Protocol: %d, Waittime: %d\n", gt->dt.xsize, gt->dt.ysize, gt->dt.protocol, gt->dt.waittime); prt(" Datadirectory: %s\n", gt->dt.datafile); } } if (!printed) prt("No games configured.\n"); } /************************************* * find_game_loc * * Find the game name in the list of games, * if it exists. * Return a pointer to the entry, and which * game number it is. */ static game_t * find_game_loc(name, which) char *name; int *which; { int i; game_t *gt; for (gt=games,i=0; idt.name[0] && !strcmp(name, gt->dt.name)) { *which = i; return(gt); } } *which = -1; return((game_t *) 0); } /************************************* * add_game */ int add_game(name, host, port, coun, rep, xsize, ysize, proto, wait, dataf) char *name, *host, *port, *coun, *rep, *dataf; int xsize, ysize, proto, wait; { int i; game_t *gt; char *strcpy(); if (find_game_loc(name, &i)) { eprt("Game %s already exists\n", name); return(0); } for (gt=games,i=0; ((idt.name[0])); gt++, i++) ; if (MAX_GAMES <= i) { eprt("Too many games configured, %d\n", MAX_GAMES); return(0); } if (strlen(name) >= sizeof(gt->dt.name)) { eprt("Name too big, max len of %d\n", sizeof(gt->dt.name)-1); return(0); } if (strlen(host) >= sizeof(gt->dt.host)) { eprt("Host too big, max len of %d\n", sizeof(gt->dt.host)-1); return(0); } if (strlen(port) >= sizeof(gt->dt.port)) { eprt("Port too big, max len of %d\n", sizeof(gt->dt.port)-1); return(0); } if (strlen(coun) >= sizeof(gt->dt.country)) { eprt("Country name too big, max len of %d\n", sizeof(gt->dt.country)-1); return(0); } if (strlen(rep) >= sizeof(gt->dt.rep)) { eprt("Rep too big, max len of %d\n", sizeof(gt->dt.rep)-1); return(0); } if (strlen(dataf) >= sizeof(gt->dt.datafile)) { eprt("Rep too big, max len of %d\n", sizeof(gt->dt.datafile)-1); return(0); } if ((xsize % 2) || (0 >= xsize)) { eprt("Xsize %d wrong. Must be even and greater than 0\n"); return(0); } if ((ysize % 2) || (0 >= ysize)) { eprt("Ysize %d wrong. Must be even and greater than 0\n"); return(0); } if (wait < 5) { eprt("Wait time of %d invalid. Should be at least 5 seconds.\n"); return(0); } (void) strcpy(gt->dt.name, name); (void) strcpy(gt->dt.host, host); (void) strcpy(gt->dt.port, port); (void) strcpy(gt->dt.country, coun); (void) strcpy(gt->dt.rep, rep); (void) strcpy(gt->dt.datafile, dataf); gt->dt.protocol = proto; gt->dt.xsize = xsize; gt->dt.ysize = ysize; gt->dt.waittime = wait; gt->socket = -1; gt->time = 0; gt->btus = 0; return(1); } void switch_gameout() { game_t *gt; if ((0 <= game_number) && (MAX_GAMES > game_number)) { /* Save the data from the current game */ gt = &games[game_number]; gt->socket = game_socket; gt->time = game_time; gt->btus = game_btus; } game_socket = -1; if (cntl.usr.homedir) chdir(cntl.usr.homedir); game_number = -1; } int switch_to(game) char *game; { int which; game_t *gt; if (!(gt=find_game_loc(game, &which))) { eprt("No such game, '%s'.\n", game); return(0); } if (game_number == which) { eprt("Already connected to '%s'.\n", game); } else { switch_gameout(); game_number = which; game_socket = gt->socket; game_time = gt->time; game_btus = gt->btus; (void) strcpy(game_name, gt->dt.name); (void) strcpy(game_host, gt->dt.host); (void) strcpy(game_port, gt->dt.port); (void) strcpy(game_country, gt->dt.country); (void) strcpy(game_rep, gt->dt.rep); game_wait = gt->dt.waittime; game_xsize = gt->dt.xsize; game_ysize = gt->dt.ysize; game_protocol = gt->dt.protocol; (void) strcpy(game_dataf, gt->dt.datafile); } /* Change to the data directory. First make sure we are at home.*/ if (cntl.usr.homedir) chdir(cntl.usr.homedir); if (chdir(game_dataf)) eprt("%d:Unable to chdir to game directory: %s\n", errno, game_dataf); return(1); } eif/gencoms.c000644 002123 000322 00000003345 05015000410 014615 0ustar00childrenpstaff000001 3012752 /************************************************************* * $Id: gencoms.c,v 1.4 91/05/17 12:10:52 dhay Exp $ * * gencoms.c * * Some general commands. */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include /* From print.c */ void prt(), eprt(); /* From the GNU readline stuff. */ int write_history(); /* From games.c */ void list_games(); /****************************************** * cmd_echo * * The "echo" command. */ void cmd_echo(buf, sub) char *buf; int sub; { while (isspace(*buf)) buf++; prt("%s\n", buf); } /****************************************** * cmd_beep * * Beep a bit. */ void cmd_beep(buf, sub) char *buf; int sub; { eprt(""); } /****************************************** * cmd_games * * Show the configured games. */ void cmd_games(buf, sub) char *buf; int sub; { char *cp; while (isspace(*buf)) buf++; cp = buf; if (*cp) { while (*cp && !isspace(*cp)) cp++; *cp = '\0'; } list_games(buf); } /****************************************** * cmd_history * */ void cmd_history(buf, sub) char *buf; int sub; { /* Need some way of adding line numbers. */ write_history("/dev/tty"); } /****************************************** * cmd_system * */ void cmd_system(buf, sub) char *buf; int sub; { int ret; ret = system(buf); if ((ret % 256) != 0) eprt("Problem in 'system' call, %d returned\n", (ret%256)); } eif/getcom.c000644 002123 000322 00000053201 05745277622 014455 0ustar00childrenpstaff000001 3011010 /************************************************************* * $Id: getcom.c,v 1.13 91/06/06 12:48:54 dhay Exp $ * * getcom.c * * Get a command, and do a bunch of things to it. * * - convert aliases * - replace variable strings * - Check if we are in if-endif sequence * - control where the command is coming from * * And a zillion other little details. */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include #include extern int Interrupt; /* True if we got a SIGINT */ extern int Pipe_Interrupt; /* True if we got a SIGPIPE */ /* From print.c */ void prt(), eprt(), output_file(); FILE *output_to(), *output_topipe(), *output_turnoff(); /* From alias.c and vars.c */ char *find_alias(), *find_var(); void clear_alias_marks(); /* From the GNU readline stuff */ char *readline(), *tilde_expand(); int history_expand(); /* System externals */ extern int errno; char *index(), *malloc(), *strcpy(), *strncpy(), *strcat(); /* Local to this file */ static int change_vars(); static void stuff_semis(); static int replace_alias(); static int find_aliasarg(); static FILE *current_input; static int current_input_isapipe; #define FSTACKMAX 40 #define FSTK_USER 0 #define FSTK_EXEC 1 #define FSTK_REDIR 2 #define FSTK_CMDPART 3 typedef struct { int type; int depth; /* Depth of if's */ int disabled; /* True if commands being ignored due to if * and the depth at which disabled. */ union { struct { FILE *oldin; int ispipe; } exec; struct { FILE *oldout; int ispipe; } redir; struct { char *cmd; } cmdpart; } un; } filesav_t; static int fsk_depth= -1; static filesav_t fstack[FSTACKMAX]; static filesav_t * fst_add(typ) int typ; { filesav_t *fs; if (fsk_depth >= FSTACKMAX-1) { eprt("Error: Too many cmd stack layers, max %d\n", FSTACKMAX); return((filesav_t *) 0); } fs = &fstack[++fsk_depth]; fs->type = typ; return(fs); } static int get_nextbit(cmd, cmdlen, prompt, sub, dontstrip) char *cmd, *prompt; int cmdlen, sub; { filesav_t *fst; static char lastcom[300]; char *cp, *bp; int cmdok; int echoed = 0; *cmd = '\0'; do { cmdok = 1; fst = &fstack[fsk_depth]; if (FSTK_CMDPART == fst->type) { cp = fst->un.cmdpart.cmd; if (!dontstrip) while (isspace(*cp)) cp++; (void) strcpy(cmd, cp); (void) free(fst->un.cmdpart.cmd); fsk_depth--; } else if (FSTK_EXEC == fst->type) { if (!fgets(cmd, cmdlen, current_input)) { if (current_input_isapipe) { pclose(current_input); } else fclose(current_input); current_input = fst->un.exec.oldin; current_input_isapipe = fst->un.exec.ispipe; fsk_depth--; prt("End of exec\n"); cmdok = 0; continue; } if (!dontstrip && isspace(*cmd)) { cp = cmd; while (isspace(*cp)) cp++; (void) strcpy(cmd, cp); } prt("%s", cmd); echoed = 1; } else if (FSTK_USER == fst->type) { if (sub) { if (prompt) eprt("%s", prompt); fflush(stdout); fflush(stderr); if (!fgets(cmd, cmdlen, stdin)) { (void) strcpy(cmd, "ctld"); clearerr(stdin); } } else { do { int eofd = 0; /* Keep reading until we get a non-null input line. */ do { if ((cp = readline(prompt))) { if (!dontstrip) while (isspace(*cp)) cp++; if (!*cp) { /* Return blank lines. */ *cmd = '\0'; return(0); } } else { if (++eofd > 20) { eprt("Error: Input eof'd more than 20 times, dying.\n"); exit(1); } } } while (!cp || !*cp); /* Now, if she input "!" or "^", we parse it here. */ if (cp && ('!' == *cp || '^' == *cp)) { if (-1 == history_expand(cp, &bp)) { eprt("Syntax: Error in history: %s\n", bp); cp = (char *) NULL; } else { cp = bp; /* Echo it to the user */ prt("%s\n",cp); echoed = 1; } } } while (!cp || !*cp); /* Only non-null, non-duplicate user input lines onto history */ if (cp && *cp) { if (*cp != lastcom[0] || (strcmp(cp, lastcom))) { add_history(cp); (void) strcpy(lastcom, cp); } } (void) strcpy(cmd, cp); } } } while (!cmdok); /* Remove any newline chars at end. */ cp = cmd; while (*cp && '\n' != *cp) cp++; *cp = '\0'; return(echoed); } /************************************ * get_main_input * * Return the next line of user input. * * We must: * Expand aliases. * Parse seperate command lines, seperated by ";". * Expand variables. */ int get_main_input(retbuf, len, prompt) char *retbuf, *prompt; int len; { filesav_t *fst; int i, cmdok, echoed=0; char *cp, *bp, *ap; char buf[300], cmd[300]; /* Initialization */ if (-1 == fsk_depth) { current_input = stdin; fsk_depth = 0; fstack[0].type = FSTK_USER; } if (Interrupt || Pipe_Interrupt) { int stop = 0; while (fsk_depth > 0 && !stop) { fst = &fstack[fsk_depth]; if (FSTK_REDIR == fst->type) { output_file(fst->un.redir.oldout, fst->un.redir.ispipe); if (fst->un.redir.ispipe && Pipe_Interrupt && !Interrupt) stop = 1; fsk_depth--; } else if (FSTK_CMDPART == fst->type) { (void) free(fst->un.cmdpart.cmd); fsk_depth--; } else if (FSTK_EXEC == fst->type) { fclose(current_input); current_input = fst->un.exec.oldin; fsk_depth--; } else { fsk_depth--; } } Interrupt = 0; Pipe_Interrupt = 0; } do { cmdok = 1; fst = &fstack[fsk_depth]; /* pop redir */ if (FSTK_REDIR == fst->type) { output_file(fst->un.redir.oldout, fst->un.redir.ispipe); fsk_depth--; cmdok = 0; continue; } echoed = get_nextbit(cmd, sizeof(cmd), prompt, 0, 0); fst = &fstack[fsk_depth]; /* Is it a comment? */ if ('#' == cmd[0]) { cmdok = 0; continue; } /* Is it a line marked for secondary input. If so, ignore */ if ('&' == cmd[0]) { stuff_semis(cmd); cmdok = 0; continue; } /* Expand any aliases */ clear_alias_marks(); do { cp = cmd; bp = buf; i = 0; while (cp && *cp && !isspace(*cp) && (++i < sizeof(buf))) *bp++ = *cp++; *bp = '\0'; if ((ap=find_alias(buf))) { if (!replace_alias(cmd, ap, cmd)) cmdok = 0; echoed = 0; } } while (ap && cmdok); if (!cmdok) continue; /* Any ";" commands to stuff into the stack? */ stuff_semis(cmd); /* Any variables to replace? */ if (!change_vars(cmd, buf)) { cmdok = 0; continue; } /* If we are disabled, we only let 'if', 'else', 'elseif', * and 'endif' through. */ if (fst->disabled) { cp = cmd; while (isspace(*cp)) cp++; if (!strncmp("if", cp, 2)) { cp += 2; if (*cp && !isspace(*cp)) cmdok = 0; } else if (!strncmp("elseif", cp, 6)) { cp += 6; if (*cp && !isspace(*cp)) cmdok = 0; } else if (!strncmp("else", cp, 4)) { cp += 4; if (*cp && !isspace(*cp)) cmdok = 0; } else if (!strncmp("endif", cp, 5)) { cp += 5; if (*cp && !isspace(*cp)) cmdok = 0; } else cmdok = 0; if (!cmdok) continue; } /* Any file redirections or pipes? */ if (!(i=find_redirs(cmd, buf))) { cmdok = 0; continue; } else if (i < 0) { /* Redirected, so command was not echoed to redir file */ echoed = 0; } } while (!cmdok); (void) strcpy(retbuf, cmd); return(echoed); } /************************************ * get_input * * No history, vars, aliases. */ int get_input(retbuf, len, prompt) char *retbuf, *prompt; int len; { filesav_t *fst; char *cp; FILE *fp; int psav, dontstrip=0; /* Tel's and ann's prompts look like " 512 left: " */ if (prompt) { cp = prompt; while (isspace(*cp)) cp++; if (isdigit(*cp)) { while (isdigit(*cp)) cp++; while (isspace(*cp)) cp++; if (!strncmp("left:", cp, 5)) dontstrip = 1; } } /* Must save redirections so output makes it to a file. */ fp = (FILE *) 0; fst = &fstack[fsk_depth]; if (fst->type == FSTK_REDIR) { fp = fst->un.redir.oldout; psav = fst->un.redir.ispipe; fsk_depth--; } /* SPECIAL for empire telegrams and announcements. */ (void)get_nextbit(retbuf, len, prompt, 1, dontstrip); if (fp) { fst = fst_add(FSTK_REDIR); fst->un.redir.oldout = fp; fst->un.redir.ispipe = psav; } /* To allow semicolons in ann & tele's, or not? * This allows them. */ if (!dontstrip) stuff_semis(retbuf); cp = retbuf; if (!dontstrip) { while (isspace(*cp)) cp++; /* If marked as an secondary input, remove marker */ if ('&' == *cp) { cp++; while (isspace(*cp)) cp++; } } if (cp != retbuf) (void) strcpy(retbuf, cp); /* Remove trailing space */ cp = retbuf; while (*cp) cp++; if (cp != retbuf) { while (isspace(*--cp) && (cp != retbuf)) ; cp++; *cp = '\0'; } if (fsk_depth) eprt("%s\n",retbuf); if (Interrupt) { return(0); } else return(1); } /************************************ * stuff_semis * * Scan cmd for ";" not inside of quotes, and * stick them on the cmd stack. */ static void stuff_semis(cmd) char *cmd; { filesav_t *fst; char *cp; cp = cmd; while (*cp) { /* Ignore things inside of quotes. */ if ('\"' == *cp) { cp++; while (*cp && '\"' != *cp) cp++; } else if (';' == *cp) { *cp++ = '\0'; if (*cp) { if (fst=fst_add(FSTK_CMDPART)) { fst->un.cmdpart.cmd = malloc(strlen(cp)+1); (void) strcpy(fst->un.cmdpart.cmd, cp); } } return; } cp++; } } /************************************ * change_vars * * Find and substitute in the $VARs in * the cmd line. * * Looking for: * $varname * ${varname} * * Return 0 if there is a problem. * Return 1 if ok. */ static int change_vars(cmd, buf) char *cmd, *buf; { int err; char *ap, *bp, *cp, *dp; /* Look for variables to expand */ /* This should probably be in a procedure.... */ for (cp=cmd; *cp; cp++) { if ('"' == *cp) { cp++; while (*cp && '"' != *cp) cp++; if ('"' != *cp) { eprt("Syntax: Missing trailing \" in '%s'\n", cmd); return(0); } } else if ('$' == *cp) { dp = cp + 1; if (*dp && !isspace(*dp)) { bp = buf; if ('{' /*}*/ == *dp) { dp++; while (*dp && /*{*/ '}' != *dp) *bp++ = *dp++; *bp = '\0'; if (!*dp || !buf[0]) { eprt("Syntax: Bad variable syntax, '%s'\n", cp); return(0); } dp++; } else { while (*dp && !isspace(*dp) && ':' != *dp) *bp++ = *dp++; *bp = '\0'; } if ((ap=find_var(buf, &err))) { *cp = '\0'; (void) strcpy(buf, cmd); (void) strcat(buf, ap); cp = cmd + strlen(buf) - 1; (void) strcat(buf, dp); (void) strcpy(cmd, buf); } else { if (err) eprt("Error: Unable to find variable '%s'\n", buf); return(0); } } } } return(1); } /************************************ * find_redirs * * Look for "|", ">", etc, in the command line. * * Let us be sleazy. * If we find a "|", pipe it into a "sh -c" for the * rest of it. * * Return 0 if there was a problem. * Return 1 if ok. * Return -1 if redirected. */ static int find_redirs(cmd, buf) char *cmd, *buf; { filesav_t *fst; char *cp, *bp, *np; FILE *fp, *output_to(), *popen(); int access = 0; cp = cmd; while (*cp && ('|' != *cp) && ('>' != *cp)) { /* Ignore quoted strings. */ if ('\"' == *cp) { cp++; while (*cp && '\"' != *cp) cp++; if (!*cp) break; } /* Empire has commands which contain '>'. */ /* However, they all follow '?' */ /* Thus, we skip over strings following '?'s */ if ('?' == *cp) { while (*cp && !isspace(*cp)) cp++; if (!*cp) break; } cp++; } if ('|' == *cp) { *cp++ = '\0'; while (isspace(*cp)) cp++; if (!*cp) { eprt("Syntax: Bad pipe. Need a destination program.\n"); return(0); } if (!(fst=fst_add(FSTK_REDIR))) return(0); /* Expand any ~'s in destination name */ np = tilde_expand(cp); /* Set up the output pipe. */ fp = output_topipe(np, &fst->un.redir.ispipe); /* tilde_expand returns an alloc'd string */ (void) free(np); fst->un.redir.oldout = fp; if (!fp) { output_file(fp, fst->un.redir.ispipe); fsk_depth--; eprt("Error: Unable to popen pipe. %d:%s\n", errno, cp); return(0); } return(-1); } else if ('>' == *cp) { *cp++ = '\0'; if ('>' == *cp) { access = 1; cp++; } else if ('!' == *cp) { access = -1; cp++; } while (isspace(*cp)) cp++; if (!*cp) { eprt("Syntax: Bad file redirection. Need a destination file.\n"); return(0); } bp = cp; while (*bp && !isspace(*bp) && ('>' != *bp) && ('!' != *bp)) bp++; if (('>' == *bp) || ('!' == *bp)) { eprt("Syntax: Bad file redirection. Only one redirection allowed.\n"); return(0); } if (*bp) *bp++ = '\0'; while (isspace(*bp)) bp++; if (*bp) { eprt("Syntax: Bad file redirection. Redirection must be last.\n"); return(0); } if (!(fst=fst_add(FSTK_REDIR))) return(0); /* Expand any ~'s in destination name */ np = tilde_expand(cp); /* Set up the output file. */ fp = output_to(np, access, &fst->un.redir.ispipe); /* tilde_expand returns an alloc'd string */ (void) free(np); fst->un.redir.oldout = fp; if (!fp) { fsk_depth--; eprt("Error: Unable to redirect to file '%s', %d.\n", cp, errno); return(0); } else if ((FILE *) -1 == fp) { fsk_depth--; eprt("Error: File %s exists, redirection failed.\n", cp); return(0); } return(-1); } return(1); } /****************************************** * cmd_exec * * Read commands from a file. * * sub = 0, read the file in. * sub = 1, execute file, and read in output from it. * sub = 2, read the file in, but don't echo the output. */ void cmd_exec(buf, sub) char *buf; int sub; { int ispipe=0; filesav_t *fst; char *cp, *nam=(char *)0; FILE *fp; /* Initialization */ if (-1 == fsk_depth) { current_input = stdin; fsk_depth = 0; fstack[0].type = FSTK_USER; } while (isspace(*buf)) buf++; if (!*buf) { eprt("Syntax: Need a filename to execute.\n"); return; } /* Expand any ~'s in filename */ /* This is in the GNU readline stuff. */ nam = tilde_expand(buf); if ((0 == sub) || (2 == sub)) { cp = nam; while (*cp && !isspace(*cp)) cp++; if (*cp) *cp++ = '\0'; while (isspace(*cp)) cp++; if (*cp) { eprt("Syntax: Extraneous characters after filename, `%s'\n", cp); goto error_ret; } if (!(fp=fopen(nam, "r"))) { eprt("Error: Unable to exec file %s, %d\n", nam, errno); goto error_ret; } /* Disable output by stacking another filetype. */ if (2 == sub) { if (!(fst=fst_add(FSTK_REDIR))) goto error_ret; fst->un.redir.oldout = output_turnoff(&fst->un.redir.ispipe); } } else if (1 == sub) { if (!(fp=popen(nam, "r"))) { eprt("Unable to execute command '%s', %d\n", nam, errno); goto error_ret; } ispipe = 1; } else { eprt("Internal Error, bad sub to cmd_exec\n"); goto error_ret; } if (!(fst=fst_add(FSTK_EXEC))) { fclose(fp); goto error_ret; } fst->un.exec.oldin = current_input; fst->un.exec.ispipe = current_input_isapipe; current_input = fp; current_input_isapipe = ispipe; error_ret: if (nam) (void) free(nam); } /****************************************** * replace_alias * * Take a command and an alias, and make up the * new command. */ static int replace_alias(cmd, alias, ret) char *cmd, *alias, *ret; { int arg; char *ap, *bp, *cp, *sp, *maxcp; char buf[300]; /* Find the end of the alias parameter. */ maxcp = cmd; while (isspace(*maxcp)) maxcp++; while (*maxcp && !isspace(*maxcp)) maxcp++; for (ap=alias,bp=buf; *ap; ap++) { /* Ignore quoted strings. */ if ('"' == *ap) { *bp++ = *ap++; while (*ap && '"' != *ap) *bp++ = *ap++; if ('"' != *ap) { eprt("Syntax: Alias missing trailing \" in '%s'\n", alias); return(0); } *bp++ = *ap; } else if ('$' == *ap) { cp = ap; cp++; if ('{' /*'}*/ == *cp) { if (!isdigit(*++cp)) { *bp++ = *ap; continue; } /* It is a ${N type variable. */ arg = atoi(cp); while (isdigit(*cp)) cp++; sp = (char *) 0; if (':' == *cp) { sp = ++cp; while (*cp && /*{*/ '}' != *cp) cp++; } if ('}' != *cp) { eprt( /*{*/"Syntax: Alias missing trailing '}' in '%s'\n", alias); return(0); } ap = cp; if (find_aliasarg(arg, cmd, &bp, sp, &maxcp, alias)) return(0); } else if (isdigit(*cp)) { /* It is a numeric variable name */ arg = atoi(cp); if (find_aliasarg(arg, cmd, &bp, (char *) 0, &maxcp, alias)) return(0); while (isdigit(*cp)) ap = cp++; } else { *bp++ = '$'; /* Special case for $$ */ if ('$' == *ap) *bp++ = *ap; } } else { *bp++ = *ap; } } *bp = '\0'; (void) strcpy(bp, maxcp); (void) strcpy(ret, buf); return(1); } /****************************************** * find_aliasarg * * Find the alias argument, and add it to the * new command being built. * * Arguments are quoted strings or space delimited words, * which can contain any characters. */ static int find_aliasarg(arg, cmd, retp, condp, maxcp, alias) int arg; char *cmd; char **retp; char *condp; char **maxcp; char *alias; { char *cp; int i; cp = cmd; i = arg; /* While characters, and not running into the next command. */ while (*cp && (';' != *cp) && (i >= 0)) { while (isspace(*cp)) cp++; /* Quoted string */ if ('"' == *cp) { cp++; while (*cp && '"' != *cp) { if (i) { cp++; } else *(*retp)++ = *cp++; } if ('"' != *cp++) { eprt("Syntax: Arg %d missing trailing \" in '%s'\n", i, cmd); return(-1); } i--; } else if (*cp && ';' != *cp) { while (*cp && ';' != *cp && !isspace(*cp)) { if (i) { cp++; } else *(*retp)++ = *cp++; } i--; } } if (cp > *maxcp) *maxcp = cp; /* We didn't find the argument. */ if (i >= 0) { if (condp) { if ('-' == *condp) { /* Use the following string */ condp++; while (*condp && /*{*/ '}' != *condp) *(*retp)++ = *condp++; if (/*{*/ '}' != *condp) { eprt(/*{*/ "Syntax: Conditional variable missing '}' in '%s'\n", alias); return(-1); } } else if ('?' == *condp) { /* Print an error, and abort command. */ char *xp; char buf[300]; xp = buf; condp++; while (*condp && /*{*/ '}' != *condp) *xp++ = *condp++; if (/*{*/ '}' != *condp) eprt(/*{*/ "Syntax: Conditional variable missing '}' in '%s'\n", alias); *xp = '\0'; eprt("%s\n", buf); return(-1); } else if ('+' == *condp) { /* Substitute nothing. */ while (*condp && /*{*/ '}' != *condp) condp++; if (/*{*/ '}' != *condp) { eprt(/*{*/ "Syntax: Conditional variable missing '}' in '%s'\n", alias); return(-1); } } else { eprt("Syntax: Bad conditional variable syntax in alias '%s`\n", alias); return(-1); } } else { eprt("Missing alias parameter %d\n", arg); return(-1); } } return(0); } /****************************************** * cmd_if * * sub: * 0 - if * 1 - elseif * 2 - else * 3 - endif */ void cmd_if(buf, sub) char *buf; int sub; { filesav_t *fst; int ret; char cmd[200]; fst = &fstack[fsk_depth]; if ((sub == 0) || (sub == 1)) { /* IF or ELSEIF */ if (sub == 1) { /* ELSEIF */ if (fst->depth <= 0) { eprt("elseif not inside an if list.\n"); return; } if (fst->disabled) { /* Lower level, or previous elseif disabled us */ if (fst->depth > fst->disabled) return; /* This level disabled us, re-enable */ fst->disabled = 0; } else { /* Disabled until endif */ fst->disabled = fst->depth - 1; prt("Commands disabled til matching endif.\n"); } } else fst->depth += 2; if (!fst->disabled) { while (isspace(*buf)) buf++; (void) sprintf(cmd, "/bin/test %s", buf); ret = system(cmd); if ((ret % 256) != 0) { eprt("Problem in system call of /bin/test, %d", (ret % 256)); eprt("Command was: %s", cmd); ret = -1; } else { ret = (ret/256) % 256; if (ret == 255) { eprt("Bad test conditons.\n"); ret = -1; } } if (ret) { if (ret == -1) { if ((fsk_depth == 0) && (fst->depth == 2)) { /* Interactive command, ignore error. */ fst->depth = 0; fst->disabled = 0; } else { /* Abort until this if is done. */ fst->disabled = fst->depth - 1; prt("Commands disabled til matching endif.\n"); } } else { fst->disabled = fst->depth; prt("Commands disabled.\n"); } } else if (sub == 1) prt("Commands enabled.\n"); } } else if (sub == 2) { if (fst->depth <= 0) { eprt("else not inside an if list.\n"); return; } /* ELSE */ if (fst->disabled) { if (fst->depth <= fst->disabled) { fst->disabled = 0; prt("Commands enabled.\n"); } } else if (fst->depth > 0) { prt("Commands disabled til matching endif.\n"); fst->disabled = fst->depth - 1; } } else if (sub == 3) { /* ENDIF */ if (fst->depth <= 0) { fst->depth = 0; if (!fst->disabled) /* So I'm paranoid */ eprt("endif not inside an if list.\n"); } else fst->depth -= 2; if (fst->disabled && (fst->depth <= fst->disabled)) { fst->disabled = 0; prt("Commands enabled.\n"); } if (fst->depth <= 0) { fst->depth = 0; fst->disabled = 0; } } } eif/init.c000644 002123 000322 00000004510 05015000410 014115 0ustar00childrenpstaff000001 3010715 /************************************************************* * $Id: init.c,v 1.4 91/05/17 12:10:56 dhay Exp $ * * init.c * * Initialize any global data that need init'ing. */ /******************************************************* * Copyright (C) Doug Hay, 1989,90,91. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include "cntl.h" #include "data.h" /* From print.c */ void prt(); static int showinit; static void set_user_info(); /**************************************** * string_env * * Look for the specified environment var. * If it doesn't exist, use the default. * Return 0 if default used, 1 if env used. */ static int string_env(whr, env, def, max) char *whr, *env, *def; int max; { int l; char *ep; char *getenv(), *strncpy(), *strcpy(); if ((ep=getenv(env))) { l = strlen(ep); if (l >= max) l = max - 1; (void) strncpy(whr, ep, l); } else { l = strlen(def); if (l >= max) l = max - 1; (void) strcpy(whr, def); } if (showinit) prt(" def: %s env: %s set: %s\n", def, env, whr); return((ep != NULL)); } void set_defaults() { char *getenv(), *strcpy(), *strcat(); set_user_info(); cntl.pid = getpid(); if (getenv("EIFSHOWINIT")) showinit = 1; if (!string_env(cntl.st.startupf, "EIFSTARTF", "", sizeof(cntl.st.startupf))) { if (cntl.usr.homedir && (strlen(cntl.usr.homedir)+8) <= sizeof(cntl.st.startupf)) { (void) strcpy(cntl.st.startupf, cntl.usr.homedir); (void) strcat(cntl.st.startupf, "/.eifrc"); cntl.st.readstartup = 1; } else cntl.st.readstartup = 0; } else cntl.st.readstartup = 1; } #include static void set_user_info() { struct passwd *pwd; char *malloc(), *strcpy(); cntl.usr.uid = getuid(); pwd = getpwuid(cntl.usr.uid); if (pwd) { cntl.usr.name = malloc((unsigned)strlen(pwd->pw_name) + 1); (void) strcpy(cntl.usr.name, pwd->pw_name); cntl.usr.homedir = malloc((unsigned)strlen(pwd->pw_dir) + 1); (void) strcpy(cntl.usr.homedir, pwd->pw_dir); cntl.usr.shell = malloc((unsigned)strlen(pwd->pw_shell) + 1); (void) strcpy(cntl.usr.shell, pwd->pw_shell); } } eif/main.c000644 002123 000322 00000013620 05023464133 014113 0ustar00childrenpstaff000001 3011170 /************************************************************* * $Id: main.c,v 1.5 91/06/06 12:52:29 dhay Exp $ * * main.c * * The main for the empire interface program EIF. * * Handles runtime command arguments. */ /******************************************************* * Copyright (C) Doug Hay, 1989,90,91. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #define MAIN #include "cntl.h" #include "data.h" /* From init.c */ void set_defaults(); /* From eif.c */ void eif_away(); /* From vars.c */ void setvar_value(); /* From print.c */ extern int disable_bell_output; #ifndef ENVARG #define ENVARG "EIFARGS" #endif static void usagequit(); static void parse_env(); static void print_help(); static void version_print(); int main (argc, argv) int argc; char *argv[]; { int t; /* Set defaults before argument parsing */ set_defaults(); /* Parse any arguments in the environment variable */ parse_env(ENVARG); /* Parse the runtime arguments */ if ((t=parse_args(argc, argv))) usagequit(t); eif_away(); } /************************************* * parse_env * * Check the given environment variable, * and if it is set, parse it as if it * were a command line option string. */ static void parse_env(env) char *env; { int l; char *val; char buf[256]; char *getenv(), *strncpy(); if ((val=getenv(env)) == NULL) return; /* Get length of variable, make sure not too long. */ l = strlen(val); if (l >= sizeof(buf)) l = sizeof(buf)-1; /* Copy it into our buffer */ (void) strncpy(buf, val, l); buf[l] = '\0'; if ((l=parse_string(buf))) { if (l != -2) fprintf(stderr, "Error in environment variable %s\n", env); usagequit(l); } } /******************************************* * parse_string * * Passed a string, make it look like an argv, * and then call parse_args on it. */ int parse_string(buf) char *buf; { int n=0, inone=0; char *cp; char *pnts[100]; pnts[n++] = buf; /* Find the start of all strings in it */ cp = buf; while (*cp) { if (*cp == ' ') { *cp = '\0'; inone = 0; } else { if (!inone) { pnts[n++] = cp; inone = 1; } } cp++; } return(parse_args(n, pnts)); } /********************************** * parse_args * * Parse the command line type args. * * Returns 0 if error. * Otherwise, pass return code to usagequit for * interpretation and error printout. * * -1 is a general parsing error, can't figure it out. * -2 is a print_help return, just to exit program. * anything else must be workout in usagequit. */ static int parse_args(argc, argv) int argc; char *argv[]; { int argi, optcont; char *arg; long atol(); argi = 0; while(++argi < argc) { /* While there are args to process */ arg = argv[argi]; if ( *arg == '-' ) { /* minus options */ optcont = 1; while ( *++arg && optcont ) { /* while option chars */ switch ( *arg ) { /* case on minus option chars */ case 'h': /* help */ print_help(); return(-2); case 'v': version_print(); return(-2); case 'b': disable_bell_output = 1; break; case 'r': cntl.st.readstartup = 0; break; case 'D': optcont = 0; if (++argi < argc) { char *vname, *vval; vname = argv[argi]; if (++argi < argc) { vval = argv[argi]; } else vval = " "; setvar_value(vname, vval); } break; default: fprintf(stderr, "Invalid option : '%c' in '%s'\n", *arg, argv[argi]); return(-1); } /* switch */ /*NOTREACHED*/ } /* while */ } else if ( *arg == '+' ) { /* plus options */ while ( *++arg ) { /* while option chars */ switch ( *arg ) { /* case on plus option chars */ case 'h': /* help */ print_help(); return(-2); case 'v': version_print(); return(-2); case 'b': disable_bell_output = 0; break; default: fprintf(stderr, "Invalid option : '%c' in '%s'\n", *arg, argv[argi]); return(-1); } /* switch */ /*NOTREACHED*/ } /* while */ } else if (*arg == ' ') { } else { /* Not an option */ setvar_value("AUTOGAME", arg); } /* end of if else sequence */ } /* end of while on arguments passed */ return(0); } /***************************************** * usagequit * * An option was incorrect. Tell what it should be, * and exit program. */ static void usagequit(typ) int typ; { if (typ == -2) { exit(0); /* Help quit. */ } else { fprintf(stderr, "Usage: [+/-hv] \n"); } fprintf(stderr, "Try -h option for help.\n"); exit(1); } static void print_help() { int i; char *p; static char *help_list[] = {" ", "This is the Empire Interface program EIF.", "", " A Doug Hay Production.", " Copyright Doug Hay, 1991.", "", " Options: ", " +/-h - print this minor help display.", " +/-v - print out the version info.", " -r - prevent reading of the ~/.eifrc file.", " -D var val - do a 'setenv var val'.", " +/-b - enable/disable ^G (bell).", #ifndef lint " ", (char *)0L #endif }; i = 0; p = help_list[i++]; while (p) { printf("%s\n", p); p = help_list[i++]; } printf(" May set any options above, as a string, in the\n"); printf(" environment variable %s\n", ENVARG); printf(" Command line options are parsed last.\n"); } static void version_print() { int i; char *p; static char *version_list[] = { #include "version.h" #ifndef lint (char *)0L #endif }; i = 0; p = version_list[i++]; while (p) { printf("%s\n", p); p = version_list[i++]; } } eif/print.c000644 002123 000322 00000016641 05745300205 014323 0ustar00childrenpstaff000001 3011200 /************************************************************* * $Id: print.c,v 1.8 91/06/06 12:52:49 dhay Exp $ * * print.c * */ /******************************************************* * Copyright (C) Doug Hay, 1989,90,91. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include /* Prevent ^G from getting out. */ int disable_bell_output = 0; /* #define FUNNY_HIGH if highlighting doesn't work on your terminal */ /* #define FUNNY_HIGH */ static int curout_isapipe; static FILE *curout = stdout; static terminited=0; static char *Terminal_SO, *Terminal_SE; static void terminit(); /******************************************* * stripprint * * Strip any EMPIRE hilighting bits from the * string, then print it to passed file. */ static void stripprint(str, out) char *str; FILE *out; { char *cp=str; if (disable_bell_output) { while (*cp) { if (*cp == 07) { if (!*(cp+1)) { *cp = 0; } else *cp = ' '; } *cp++ &= 0x7f; } } else { while (*cp) *cp++ &= 0x7f; } fprintf(out, "%s", str); } /******************************************* * hiprint * * Find any characters in passed string with EMPIRE * highlighting bits set, and hilight those characters. */ static void hiprint(str, out) char *str; FILE *out; { char *cp; int hav_hi = 0; if (!terminited) { terminited = 1; terminit(); } /* This routine uses "fprintf" instead of "fputs". Why? * Because of an amazing fputs bug in SunOS 4.0.2 on 386i's. * And since I'm stuck with it, so are you. */ if (disable_bell_output) { for (cp=str; *cp; cp++) { if (*cp & 0x80) hav_hi = 1; if (*cp == 07) { if (!*(cp+1)) { *cp = 0; } else *cp = ' '; } } } else { for (cp=str; *cp; cp++) { if (*cp & 0x80) hav_hi = 1; } } if (!hav_hi || !Terminal_SO || !Terminal_SE || !*Terminal_SO || !*Terminal_SE) { if (hav_hi) for (cp=str; *cp; cp++) *cp &= 0x7f; fprintf(out, "%s", str); } else { for (cp=str; *cp;) { if (*cp & 0x80) { fprintf(out, "%s", Terminal_SO); for ( ; (*cp & 0x80 && putc((*cp & 0x7f), out)); cp++); fprintf(out, "%s", Terminal_SE); } else putc(*cp++, out); } } } /******************************************* * prt * * A printf equivalent. * Used to control printout levels, and * to copy output to files if necessary. */ /*VARARGS1*/ void prt(str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) char *str; int *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10; { char buf[300]; (void) sprintf(buf, str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); if ((curout == stdout) || (curout == stderr)) { hiprint(buf, curout); } else if (curout) { stripprint(buf, curout); } } /******************************************* * put * * Print a single character to current output. */ void put(c) char c; { if (curout) putc(c, curout); } /******************************************* * myfputs * * Put string to a file. */ void myfputs(str, fp) char *str; FILE *fp; { if ((fp == stdout) || (fp == stderr)) { hiprint(str, fp); } else stripprint(str, fp); } /******************************************* * eprt * * Print string to stderr. * Echo to current output if not to the display. */ /*VARARGS1*/ void eprt(str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) char *str; int *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10; { char buf[300]; (void) sprintf(buf, str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); hiprint(buf, stderr); if ((curout != stdout) && (curout != stderr) && curout) stripprint(buf, curout); } /******************************************* * notstdio_prt * * Print if current output is not to terminal. */ /*VARARGS1*/ void notstdio_prt(str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) char *str; int *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10; { char buf[300]; (void) sprintf(buf, str, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); if ((curout != stdout) && (curout != stderr) && curout) stripprint(buf, curout); } /******************************************* * output_curout * * Return the current output file, so it can * be used for something. */ FILE * output_curout() { return(curout); } /******************************************* * output_file * * Close current output if not display, and * make passed file current output. * * Used to recover after a redirection. */ void output_file(fp, ispipe) FILE *fp; int ispipe; { if (fp && (fp == curout)) return; if (curout && (curout != stdout) && (curout != stderr)) { if (curout_isapipe) { pclose(curout); } else fclose(curout); } curout = fp; curout_isapipe = ispipe; } /******************************************* * output_to * * Open file with given access, and make it current * output. * Return current output so that it may be recovered * when done with new file. */ FILE * output_to(name, access, oldispipe) char *name; int access; int *oldispipe; { FILE *fp, *fp2; char *acc="a"; if (!access) { if (fp=fopen(name, "r")) { fclose(fp); return((FILE *) -1); } } else if (0 > access) { acc = "w"; } if (!strcmp(name, "-")) { fp2 = curout; curout = stdout; *oldispipe = curout_isapipe; curout_isapipe = 0; return(fp2); } else if ((fp=fopen(name, acc))) { fp2 = curout; curout = fp; *oldispipe = curout_isapipe; curout_isapipe = 0; return(fp2); } return((FILE *) 0); } /******************************************* * output_topipe * * Open a pipe to given command, and make it current * output. * Return current output so that it may be recovered * when done with new file. */ FILE * output_topipe(cmd, oldispipe) char *cmd; int *oldispipe; { FILE *fp, *fp2; if ((fp=popen(cmd, "w"))) { fp2 = curout; curout = fp; *oldispipe = curout_isapipe; curout_isapipe = 1; return(fp2); } return((FILE *) 0); } /******************************************* * output_turnoff * * Disable any output. * Return current output so that it may be recovered * when done with new file. */ FILE * output_turnoff(oldispipe) int *oldispipe; { FILE *fp2; fp2 = curout; curout = (FILE *) 0; *oldispipe = curout_isapipe; curout_isapipe = 0; return(fp2); } /******************************************* * terminit * * Go find the highlighting strings for the terminal. */ static void terminit() { char *getenv(), *tgetstr(); char *cp, *term; static char nullstring[2]; static char termbuf[1024]; static char data[1024]; static char *area; area = data; Terminal_SO = Terminal_SE = nullstring; term = getenv("TERM"); if (!term) { fprintf(stderr, "Unable to get TERM environment variable.\n"); return; } if (tgetent(termbuf, term) == -1) { fprintf(stderr, "terminit tgetent failed\n"); return; } cp = area; if (tgetstr("so", &area) == NULL) { #if 0 fprintf(stderr, "terminit, no so\n"); #endif } else Terminal_SO = cp; cp = area; if (tgetstr("se", &area) == NULL) { #if 0 fprintf(stderr, "terminit, no se\n"); #endif } else Terminal_SE = cp; #ifdef FUNNY_HIGH ++Terminal_SO; ++Terminal_SE; #endif } eif/vars.c000644 002123 000322 00000015772 05015000411 014131 0ustar00childrenpstaff000001 3011210 /************************************************************* * $Id: vars.c,v 1.5 91/05/17 12:11:02 dhay Exp $ * * vars.c * * Maintain the user variables. * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include typedef struct { char *name; char *value; } var_t; static var_t *var_list; static int maxvars = 0; char *sprintf(), *getenv(), *strcpy(), *malloc(), *calloc(); void eprt(); void setvar_value(); /* Special vars. */ typedef struct { var_t vt; int type; int setable; } intvar_t; #define IV_PID 1 #define IV_INPUT 2 intvar_t intvar_list[] = { { {"$", ""}, IV_PID, 0}, { {"<", ""}, IV_INPUT, 0}, { {"",""}, 0, 0} }; /*********************************** * find_var_loc * * Find the matching var, if it exists. */ static var_t * find_var_loc(buf) char *buf; { int i; var_t *vp; for (vp=var_list,i=0; iname && !strcmp(vp->name, buf)) return(vp); } return((var_t *) 0); } /*********************************** * find_var_int * * Find the var, if it exists, and return a * pointer to it's value. */ static intvar_t * find_var_int(buf) char *buf; { intvar_t *ivp; for (ivp=intvar_list; ivp->type; ivp++) { if (ivp->vt.name && !strcmp(ivp->vt.name, buf)) return(ivp); } return((intvar_t *) 0); } /*********************************** * find_var * * Find the var, if it exists, and return a * pointer to it's value. * * ${varname} - Try for variable. * ${%varname} - Try for an external environment variable. * ${var:-word} - If "var" is set and non-null, substitute its value, * otherwise use word. * ${var:=word} - If "var" is not set, or null, set variable to word * and replace with word. * ${var:?word} - If "var" is set and non-null, use it's value. Otherwise, * print "word" and abort the command. * ${var:+word} - If "var" is set and non-null, substitute word. Otherwise, * substitute nothing. * All this stolen from "sh". * ${var:%word} - Use "word" as a prompt if "var" == "<". Ignored elsewhere. * * * * Note that by the time the variable string gets here, the * "$" and "{}"s have been stripped off. */ char * find_var(buf, err) char *buf; int *err; { intvar_t *ivp; var_t *vp; char *bp, *valp=0; int mode=0; static char rbuf[100]; *err = 1; bp = buf; while (*bp && ':' != *bp) bp++; if (':' == *bp) { *bp++ = '\0'; switch (*bp++) { case '-': mode = 1; break; case '=': mode = 2; break; case '?': mode = 3; break; case '+': mode = 4; break; case '%': mode = 5; break; default: return((char *) 0); } } if ('%' == *buf) { if (*++buf) valp = getenv(buf); } else if ((ivp=find_var_int(buf))) { switch (ivp->type) { case IV_PID: (void) sprintf(rbuf, "%d", getpid()); valp = rbuf; break; case IV_INPUT: if (mode == 5) { get_input(rbuf, sizeof(rbuf), bp); } else get_input(rbuf, sizeof(rbuf), (char *) 0); valp = rbuf; break; default: /* This ain't the user's fault... */ (void) strcpy(rbuf, "Bad internal variable type."); return(rbuf); } } else if ((vp=find_var_loc(buf))) { if (vp->value) { valp = vp->value; } else valp = ""; } switch (mode) { case 0: /* ${var} */ case 5: /* ${var:%word} */ return(valp); case 1: /* ${var:-word} */ if (valp && *valp) { return(valp); } else { (void) strcpy(rbuf, bp); return(rbuf); } case 2: /* ${var:=word} */ if (valp && *valp) { return(valp); } else { (void) strcpy(rbuf, bp); setvar_value(buf, bp); /* Need to set variable value. */ return(rbuf); } case 3: /* ${var:?word} */ if (valp && *valp) { return(valp); } else { if (*bp) eprt("%s\n", bp); *err = 0; return((char *) 0); } case 4: /* ${var:+word} */ if (valp && *valp) { return(bp); } else return(""); } return(valp); } /*********************************** * cmd_setvar * * varname [= value] * varname [= "value"] */ void cmd_setvar(var, sub) char *var; int sub; { char *what, *cp; while (isspace(*var)) var++; if (!*var) { eprt("Need variable name.\n"); return; } what = var; while (*what && !isspace(*what)) what++; if (*what) *what++ = '\0'; while (isspace(*what)) what++; if ('=' == *what) { what++; while (isspace(*what)) what++; } if ('\"' == *what) { cp = ++what; while (*cp && '\"' != *cp) cp++; *cp = '\0'; } else { cp = what; while (*cp && !isspace(*cp)) cp++; *cp = '\0'; } setvar_value(var, what); } /*********************************** * setvar_value * * Make the variable "var" be "what". */ void setvar_value(var, what) char *var, *what; { int t; char *cp; intvar_t *ivp; var_t *vt; if ('%' == *var) { var++; if (!*var) { eprt("External variable name incomplete.\n"); return; } #if 0 setenv(var, what, 1); #else eprt("This OS does not support setting external variables.\n"); #endif } else if ((ivp=find_var_int(var))) { if (!ivp->setable) { eprt("Sorry, special variable %s is not setable\n", ivp->vt.name); return; } eprt("Sorry, unimplemented.\n"); } else if ((vt=find_var_loc(var))) { t = strlen(what); if (vt->value && (strlen(vt->value) >= t)) { (void) strcpy(vt->value, what); } else { if (vt->value) (void) free(vt->value); cp = malloc((unsigned)t+1); (void) strcpy(cp, what); vt->value = cp; } } else { /* Try to find a free entry */ for (vt=var_list,t=0; ((tname); vt++,t++) ; if (t >= maxvars) { vt = (var_t *) calloc((unsigned)maxvars+10, sizeof(*vt)); if (var_list) { bcopy((char *) var_list, (char *) vt, (maxvars*sizeof(*vt))); (void) free((char *)var_list); } var_list = vt; vt = &vt[maxvars]; maxvars += 10; } cp = malloc((unsigned)(strlen(var) + 1)); (void) strcpy(cp, var); vt->name = cp; cp = malloc((unsigned)(strlen(what) +1)); (void) strcpy(cp, what); vt->value = cp; } } /*********************************** * cmd_unsetvar */ void cmd_unsetvar(var, sub) char *var; int sub; { var_t *vt; while (isspace(*var)) var++; if (!*var) { eprt("Need variable name.\n"); return; } if ('%' == *var) { var++; if (!*var) { eprt("External variable name incomplete.\n"); return; } #if 0 unsetenv(var); #else eprt("This OS does not support unsetting external variables.\n"); #endif } else if (find_var_int(var)) { eprt("Sorry, you cannot unset one of the special variables.\n"); } else if ((vt=find_var_loc(var))) { (void) free(vt->name); (void) free(vt->value); vt->name = (char *) 0; vt->value = (char *) 0; } else eprt("%s not found.\n", var); } eif/version.h000644 002123 000322 00000001751 05015000426 014655 0ustar00childrenpstaff000001 3011217 /* This file is automatically created by MAKE. */ /* It is included by main.c, used for the -v (version) option */ " cntl.h,v 1.5 91/05/17 12:11:17 dhay Exp ", " data.h,v 1.4 91/05/17 12:11:37 dhay Exp ", " eif.c,v 1.8 91/05/17 12:10:48 dhay Exp ", " alias.c,v 1.4 91/05/17 12:10:28 dhay Exp ", " compick.c,v 1.6 91/05/17 12:10:47 dhay Exp ", " empcon.c,v 1.5 91/05/17 12:10:50 dhay Exp ", " games.c,v 1.5 91/05/17 12:10:51 dhay Exp ", " gencoms.c,v 1.4 91/05/17 12:10:52 dhay Exp ", " getcom.c,v 1.11 91/05/17 12:10:53 dhay Exp ", " init.c,v 1.4 91/05/17 12:10:56 dhay Exp ", " main.c,v 1.4 91/05/17 12:10:57 dhay Exp ", " print.c,v 1.6 91/05/17 12:10:59 dhay Exp ", " vars.c,v 1.5 91/05/17 12:11:02 dhay Exp ", " connect.c,v 1.6 91/05/17 12:02:35 dhay Exp ", " expect.c,v 1.4 91/05/17 12:02:45 dhay Exp ", " login.c,v 1.3 91/05/17 12:02:47 dhay Exp ", " sock.c,v 1.6 91/05/17 12:02:48 dhay Exp ", " Host: swen2 ", eif/Makefile000644 002123 000322 00000012057 05745514174 014477 0ustar00childrenpstaff000001 3011410 #################################### # $Id: Makefile,v 1.3 91/05/17 12:09:42 dhay Exp $ # # EIF Makefile, D.Hay # # Targets: # all - eif # eif - make the program # #******************************************************* #* Copyright (C) Doug Hay, 1989,90,91. #* Permission to use and abuse this code, as long #* as this copyright notice stays intact and with the #* code. No warranty implied. This code supplied as is. #******************************************************* ################### # Compile flags CFLAGS = $(FLAGS) LINTFLAGS = -u -h -x -v $(FLAGS) LINT = /bin/lint MKDEPFLAGS = $(FLAGS) TARFILE = eif.tar BKUPDIR = ../bkup BKUPBASE = eif.tar.Z # Might need -ltermcap instead of -lcurses, depending on your OS FLAGS = -O SLIBS = -lcurses -lm LLIBS = libreadline.a connect.a # List of what we want to create DESTS = \ eif DESTSALL = $(DESTS) # All the include files INC = \ cntl.h\ data.h INCCONNECT = \ connect/proto.h INCCONSTRUCTED = version.h INCALL = $(INC) $(INCCONSTRUCTED) $(INCCONNECT) INCNOCONST = $(INC) # All the source routine files SRCLOC = \ eif.c\ alias.c\ compick.c\ empcon.c\ games.c\ gencoms.c\ getcom.c\ init.c\ main.c\ print.c\ vars.c SRCCONNECT = \ connect/connect.c \ connect/expect.c \ connect/login.c \ connect/sock.c SRCALL = $(SRCLOC) $(SRCCONNECT) LINTALL = $(SRCALL:.c=.ln) # List of intermediate object files OBJSLOC = $(SRCLOC:.c=.o) OBJSCONNECT = $(SRCCONNECT:.c=.o) # All the utility files UTILS = \ Makefile\ RCS/.\ connect/RCS/.\ readline FILESALL = $(UTILS) $(INCALL) $(SRCALL) default: $(DESTS) @echo "done default" .PRECIOUS: $(FILESALL) all: $(DESTSALL) echo "done all" libreadline.a: cd readline ; $(MAKE) ; cp libreadline.a .. connect.a: $(OBJSCONNECT) rm -f $@ ar ru $@ $(OBJSCONNECT) ranlib $@ eif: $(OBJSLOC) $(LLIBS) $(CC) $(CFLAGS) -o $@ $(OBJSLOC) $(LLIBS) $(SLIBS) # Some utility targets cleanreadline: cd readline ; $(MAKE) clean clean: cleanreadline rm -f *.o *.ln core a.out cpr.list $(OBJSCONNECT) $(LLIBS) cleanall veryclean: clean rm -f $(DESTS) lint: $(LINTALL) $(LINT) $(LINTFLAGS) $(LINTALL) .c.o: $(CC) $(CFLAGS) -c -o $@ $< .c.ln: $(LINT) $(LINTFLAGS) -i $< # Make a tarfile of all useful files tarall tar: $(TARFILE).Z $(TARFILE).Z : cleanreadline $(FILESALL) tar -cvf $(TARFILE) $(FILESALL) compress $(TARFILE) bkup: $(TARFILE).Z chmod a-wx $(TARFILE).Z DT=`date +%y%m%d`;mv $(TARFILE).Z $(BKUPDIR)/$(BKUPBASE).$$DT cd $(BKUPDIR) ; make rdist # depend # Use -M option of cc to output dependancies. # Change ..//../fn to ../fn (sed) # Remove /usr/include/fn files (sed) # Put more than one dependancy on a line, up to 78 chars. # Add a .ln dependancy to each .o dependancy. (sed) (for lint) depend: rm -f eddep makedep makelndep $(CC) -M $(MKDEPFLAGS) $(SRCALL) | \ sed -e ':loop' -e 's/\.\.\/[^ /]*\/\.\./../' \ -e 's/^.*\/usr\/include\/.*$$//' -e 't loop' | \ awk ' { if ($$1 != "") { if ($$1 != prev) \ { print rec; rec = $$0; prev = $$1; } \ else { if (length(rec $$2) > 68) { print rec; rec = $$0; } \ else rec = rec " " $$2 } } } \ END { print rec } ' | \ sed -e 's/^.*\.o:/& &.ln:/' -e 's/\.o:\.ln:/.ln:/' \ -e /.*:.*:/s/:// >> makedep echo '/^# DO NOT DELETE THIS LINE/+1,$$d' >eddep echo '$$r makedep' >>eddep echo 'w' >>eddep cp Makefile Makefile.bak ex - Makefile < eddep rm eddep makedep # Remove all the depend stuff at the end. dependclean: rm -f eddep echo '/^# DO NOT DELETE THIS LINE/+2,$$d' >eddep echo 'w' >>eddep cp Makefile Makefile.bak ex - Makefile < eddep rm -f eddep # version.h # A file containing all the RCS header strings, for use # in a version command. # Use ident to grab RCS id strings. # egrep strips anything not Header or Id. # sed adds stuff to make it an array declaration. #version.h: $(INCNOCONST) $(SRCALL) version.h: $(INCNOCONST) @echo "Making $@" @rm -f $@ @echo "/* This file is automatically created by MAKE. */" > $@ @echo "/* It is included by main.c, used for the -v (version) option */" >> $@ @ident -q $(INCNOCONST) $(SRCALL) | \ egrep '(Header|Id)' | \ sed -e 's/$$Header:/"/' \ -e 's/$$Id:/"/' \ -e 's/$$$$/",/' \ >> $@ @echo \" Host: `hostname` \", >>$@ @chmod a-w $@ # Everything after this line changes, in "make depend" # DO NOT DELETE THIS LINE (or the following blank line) eif.c: eif.o eif.ln: eif.c ./cntl.h ./data.h alias.c: alias.o alias.ln: alias.c compick.c: compick.o compick.ln: compick.c empcon.c: empcon.o empcon.ln: empcon.c ./cntl.h ./data.h games.c: games.o games.ln: games.c ./cntl.h ./data.h gencoms.c: gencoms.o gencoms.ln: gencoms.c getcom.c: getcom.o getcom.ln: getcom.c init.c: init.o init.ln: init.c ./cntl.h ./data.h main.c: main.o main.ln: main.c ./cntl.h ./data.h ./version.h print.c: print.o print.ln: print.c vars.c: vars.o vars.ln: vars.c connect/connect.c: connect.o connect.ln: connect/connect.c connect/expect.c: expect.o expect.ln: connect/expect.c connect/proto.h connect/login.c: login.o login.ln: connect/login.c connect/proto.h connect/sock.c: sock.o sock.ln: connect/sock.c connect/proto.h eif/SYNTAX000644 002123 000322 00000017603 05023465406 014003 0ustar00childrenpstaff000001 3011420 ============================================================================ EIF (Empire InterFace) General Syntax ============== There are 2 types of input. First, command level. This is the normal input. The second is "secondary" input, in which a command asks you a question. Such as doing a "map" command without specifying a range. Command Level ------------- Any line with a "#" as the first non-space character is a comment line, and is ignored. Any line with a "&" as the first non-space character is marked as only for secondary input, and is ignored. More on this later. "$var"s are replaced with the value of the variable "var". See below. Leading spaces on a command line are ignored, and not sent to empire. Multiple commands may be entered on the same line, with the commands seperated by a ";" character. IE, "nation ; power" will perform a nation, then a power command. ";"s inside of quoted strings (") are ignored for this. (NOTE that ";" will not seperate lines inside of telegrams and announcements. Otherwise you can't get ";" into them. Not sure if this is proper, but....) Output is redirected using ">". ">fname" - direct this command's output into the file "fname". File must NOT exist. Command aborted if it does. ">>fname" - this command's output is appended to the file "fname". The file may or may not exist. ">!fname" - this command's output written to the file "fname". Any existing data in the file is wiped. Redirection supports ~/filename. Piping is supported, through the "|" type syntax. "list | more" will pipe the list command into more. Piping supports ~/filename. Aliases are supported. If the first non-space string on a command line matches an alias, the string is replaced with the alias. NOTE that string in this context can have any characters but spaces, not withstanding any other special characters. (#,&,!!,^) Command history is supported. "^p" - moves backwards in command history. "^n" - moves forewards in command history. "!!" - repeat last command. "!str" - repeat last command which started with "str". "!?str?" - repeat last command which contained "str". "!n" - repeat the nth command, where n is a number. "!-n" - repeat the nth previous command, where n is a number. "^s1^s2" - repeat the previous command, replacing string s1 with string s2. Other variants. Read the "history.texinfo" in the readline directory. And "readline.texinfo". Exec files are supported, along with exec's inside of execs. Secondary Input --------------- This is input that commands request. IE, asking questions that you didn't answer in the command line, or were unable to answer until the command was started. This creates problems for exec files, aliases, etc, since you are not always sure how many questions will be asked. Thus, you can mark secondary input lines with a leading "&". This prevents the secondary input lines as being attempted as commands. IE, "read >>read ; &y ; &n" will avoid that annoying problem of telegrams arriving while reading. And, "build plane 16,2 ; &fighter 2 ; & " fixes the problem of not being able to specify multiword entries in a single line. (Typing "build plane 16,2 fighter 2 100" will try to build you a 'fighter 1' at tech 2.) Preconditioning: - leading spaces are removed. Spaces after the "&", as well as the "&", are removed. - trailing spaces are removed. ("ssm 2 " is not == "ssm 2".) This preconditioning is not done for telegrams and announcements, through a special case which examines the prompt string. Aliases ------- 'alias' - list all the aliases 'alias word' - show what alias 'word' is. 'alias word command' - create/change alias 'word' to command. 'alias word "command"' - ditto, but the "s are removed. Allows embedding of several commands inside one alias. ie, 'alias dd "dump #0 >!dmp; map #0 >!map"' 'unalias word' - delete the alias for 'word', if it exists. The variables $0, $1, $2, ... are supported for aliases. They are the "words" in the command that the alias is working on. Also, these variables can be conditional. ${N:-word} uses "word" if argument N does not exist. ${N:?word} prints out "word" and aborts command if N does not exist. ${N:+word} uses nothing if argument N does not exist. "words" are space delimited, or surrounded by "s. Example: local% alias tt "echo 0-$0 1-$1 2-$2" local% tt a b c d e f 0-tt 1-a 2-b c d e f local% tt "a b" c d e f 0-tt 1-a b 2-c d e f EXEC ---- exec filename - execute the commands in "filename". exec's are allowed to be recursive, but at this time there is a minor bug when the exec file ends on secondary input. Input is redirected to stdin, and not the calling exec file. Fixed some day. output redirection handles recursive execs. VARIABLES --------- $$ - process id. $< - read from stdinput. ${<:%word} - read from stdinput, using "word" as a prompt. $%name - retrieve "name" from the runtime environment, using getenv(). $name - replace with value of "name". ${name} - replace with value of name. ${name:-word} - if name is not set, or null, use "word" instead. ${name:=word} - if name is not set, or null, use "word", and set variable to "word". ${name:?word} - if name not set, or null, print "word" and abort command. ${name:+word} - if name not set, or null, substitute nothing. ${name:%word} - use "word" as prompt if "name" == "<". ":%word" ignored elsewhere. setvar name string setvar name "string" setvar name unsetvar name COMMANDS -------- The current list of commands are: alias - setting aliases. unalias - remove an alias. echo - print out the rest of the line. beep - make a beep. games - show the games that are configure in. addgame - add a game. connect - connect to a game. kill - kill a hung game process. (Only works if server supports it.) try - try a country/rep at a given game. trykill - kill a hung game process for a country/rep at a given game. exit - quit the program cmdlist - list these commands exec - exeute a file. Supports ~/filename. runfeed - exeute a program, and use its output as eif commands. history - display a listing of the command history. setvar - set a variable. unsetvar - delete a variable. @ - pass the rest of the command off to the system to execute. if - Uses /bin/test, and stops at endif. Disables command if test returns false. Can be nested. Cannot span exec files. elseif - Next case in an if sequence, same testing as 'if'. else - Last case in an if sequence. endif - Ends an 'if' sequence. The file "$HOME/.eifrc" is read in and executed as an exec file. AUTOCONNECTION -------------- The variable "AUTOGAME" is set if there is a game name specified in the runtime options. I.E., "eif mygame" would be equivalent to "setenv AUTOGAME mygame" With the last line in the .eifrc file is: "connect ${AUTOGAME:?}" an autoconnect function is served. RUNTIME OPTIONS --------------- There is currently only 2 useful runtime options: -D varname value Which is equivalent to "setenv varname value". -r Which disables reading in of ~/.eifrc at startup. OTHER THINGS ------------ When "connecting" to a game, the program does a chdir to the directory specified in the "addgame" command. Thus, you can have multiple games, in multiple directories, so that your data files for things like "ve" don't get messed up. NOTE that the directory name in "addgame" is relative to your home directory. ============================================================================ eif/Ann000644 002123 000322 00000003041 05015007427 013457 0ustar00childrenpstaff000001 3011036 Announcing the first general release of EIF. A new Empire InterFace. Early this year I finally decided that emp_client was insufficient for my needs. After looking around at several of the other clients underdevelopment, I decided that they were also insufficient for my desires. I wanted a better interface, not something that played my game for me. So... eif was born. What is eif? Aliases with parameters. Command history, substitution, etc. Courtesy of GNU. Variables. Minor conditionals. (if, elseif, else, endif) Various forms of file redirection, piping and execution. What doesn't eif do? Eif does not play your game for you. Use GEET, Eddie or Xemp. Eif knows next to nothing about the game of empire. Eif does not use Xwindows, Sunview, etc. It is command line based. Where is eif? At an ftp site near you. Support? Virtually non-existent. This may be the one and only release of eif. It has been tested quite a bit, and hopefully has no major bugs left. Enhancements? Code them yourself. OS's? Known to compile and run on SunOS and MipsOS. Probably most others as well. Previous Versions There are a couple of beta test versions that are wandering around. This fixes most/all of the known bugs with those, and has a couple of enhancements. Also, a lot of the code was restructured. But, use what you want. Disclaimer Standard disclaimer. For free? You fix it. Good Luck, and may you lose gracefully. Doug Hay dhay@swen2.waterloo.edu <- But not after July 1991. Aliens eif/readline000755 002123 000322 00000000000 05745514661 014563 5ustar00childrenpstaff000003 3046564 eif/readline/COPYING000644 002123 000322 00000031201 05012414736 015644 0ustar00childrenpstaff000003 3026330 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! eif/readline/ChangeLog000644 002123 000322 00000033555 05354425340 016404 0ustar00childrenpstaff000003 3026340 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. eif/readline/Makefile.in000644 002123 000322 00000013545 05613305201 016662 0ustar00childrenpstaff000003 3023162 # 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 = -g LDFLAGS = -g # 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 eif/readline/README000644 002123 000322 00000000424 05540143420 015477 0ustar00childrenpstaff000003 3047164 This 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. eif/readline/STANDALONE000644 002123 000322 00000002232 05612770323 016167 0ustar00childrenpstaff000003 3054300 This 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 eif/readline/ansi_stdlib.h000644 002123 000322 00000002450 05617733404 017270 0ustar00childrenpstaff000003 3054302 /* 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 */ eif/readline/bind.c000644 002123 000322 00000106213 05617733404 015705 0ustar00childrenpstaff000003 3026410 /* 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); } eif/readline/chardefs.h000644 002123 000322 00000006211 05617733404 016556 0ustar00childrenpstaff000003 3035072 /* 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 #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 */ eif/readline/complete.c000644 002123 000322 00000112626 05617733404 016610 0ustar00childrenpstaff000003 3026520 /* 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 */ eif/readline/display.c000644 002123 000322 00000106103 05617733404 016443 0ustar00childrenpstaff000003 3026570 /* 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++; } eif/readline/doc000755 002123 000322 00000000000 05745515024 015310 5ustar00childrenpstaff000003 3110337 eif/readline/doc/readline.3000644 002123 000322 00000073410 05613031335 017235 0ustar00childrenpstaff000003 3065060 .\" .\" MAN PAGE COMMENTS to .\" .\" Chet Ramey .\" Information Network Services .\" Case Western Reserve University .\" chet@ins.CWRU.Edu .\" .\" Last Change: Mon Jun 13 20:06:14 EDT 1994 .\" .TH READLINE 3 "1994 June 13" GNU .\" .\" File Name macro. This used to be `.PN', for Path Name, .\" but Sun doesn't seem to like that very much. .\" .de FN \fI\|\\$1\|\fP .. .SH NAME readline \- get a line from a user with editing .SH SYNOPSIS .LP .nf .ft B #include #include .ft .fi .LP .nf .ft B typedef int Function (); .LP .nf .ft B char *readline (prompt) char *prompt; .ft .fi .LP .nf .ft B int rl_add_defun (name, function, key) char *name; Function *function; int key; .ft .fi .LP .nf .ft B int rl_bind_key (key, function) int key; Function *function; .ft .fi .LP .nf .ft B int rl_unbind_key (key) int key; .ft .fi .LP .nf .ft B int rl_bind_key_in_map (key, function, keymap) int key; Function *function; Keymap keymap; .ft .fi .LP .nf .ft B int rl_unbind_key_in_map (key, keymap) int key; Keymap keymap; .ft .fi .ft B int rl_macro_bind (keyseq, macro, keymap) char *keyseq, *macro; Keymap keymap; .ft .fi .LP .nf .ft B int rl_variable_bind (variable, value) char *variable, *value; .ft .fi .LP .nf .LP .nf .ft B int rl_parse_and_bind (line) char *line; .ft .fi .LP .nf .ft B int rl_translate_keyseq (keyseq, array, len) char *keyseq, *array; int *len; .ft .fi .LP .nf .ft B Function *rl_named_function (command) char *command; .ft .fi .LP .nf .ft B Function *rl_function_of_keyseq (keyseq, keymap, type) char *keyseq; Keymap keymap; int *type; .ft .fi .LP .nf .ft B char **rl_invoking_keyseqs (function) Function *function; .ft .fi .LP .nf .ft B char **rl_invoking_keyseqs_in_map (function, keymap) Function *function; Keymap keymap; .ft .fi .LP .nf .ft B void rl_function_dumper (readable) int readable; .ft .fi .LP .nf .ft B char **rl_funmap_names () .ft .fi .SH COPYRIGHT .if n Readline is Copyright (C) 1989, 1991 by the Free Software Foundation, Inc. .if t Readline is Copyright \(co 1989, 1991 by the Free Software Foundation, Inc. .SH DESCRIPTION .LP .B readline will read a line from the terminal and return it, using .B prompt as a prompt. If .B prompt is null, no prompt is issued. The line returned is allocated with .IR malloc (3), so the caller must free it when finished. The line returned has the final newline removed, so only the text of the line remains. .LP .B readline offers editing capabilities while the user is entering the line. By default, the line editing commands are similar to those of emacs. A vi\-style line editing interface is also available. .LP In the following descriptions, .B keymap can be one of \fIemacs_keymap, emacs_meta_keymap, emacs_ctlx_keymap, vi_insertion_keymap, or vi_movement_keymap\fP. .LP .B rl_add_defun makes .B name appear as a bindable readline command, and makes .B function be the function called when that command is invoked. If .B key is not \-1, it is bound to .B function in the current keymap. .LP .B rl_bind_key causes .B key to invoke .BR function . The binding is made in the current keymap. .LP .B rl_unbind_key removes the binding for .B key in the current keymap. .LP .B rl_bind_key_in_map makes the .B key entry in .B keymap invoke .BR function . .LP .B rl_unbind_key_in_map removes the binding for .B key in keymap .BR keymap . .LP .B rl_macro_bind makes .B keyseq insert the string .BR macro . The binding is performed in .BR keymap . .LP .B rl_variable_bind sets the value of the readline variable .B variable to .BR value . .LP .B rl_parse_and_bind takes as an argument a line of the same form as the readline startup file (see .SM .B INITIALIZATION FILE below) and executes the commands therein. .LP .B rl_translate_keyseq converts .B keyseq into a new string, storing the result in .BR array . This translates control and meta prefixes and the readline character escape sequences (see .SM .B Key Bindings below). The length of the translated sequence is returned in .BR *len . .LP .B rl_named_function returns the function that is executed when the readline command .B command is invoked. .LP .B rl_function_of_keyseq returns the function that is executed when .B keyseq is read and .B keymap is the current keymap. .B type is set to indicate whether the return value corresponds to a function, macro, or auxiliary keymap. .LP .B rl_invoking_keyseqs returns all of the key sequences in the current keymap that invoke .BR function . .LP .B rl_invoking_keyseqs_in_map returns all of the key sequences in .B keymap that invoke .BR function . .LP .B rl_function_dumper prints all of the readline functions and their bindings to the readline output stream. If .B readable is non\-zero, the output is formattted so that it can be read back in to restore the bindings. .LP .B rl_funmap_names returns an array of all known readline bindable function names. The array is sorted. .SH RETURN VALUE .LP .B readline returns the text of the line read. A blank line returns the empty string. If .B EOF is encountered while reading a line, and the line is empty, .B NULL is returned. If an .B EOF is read with a non\-empty line, it is treated as a newline. .LP Unless otherwise stated, the other functions return 0 on success and non\-zero on failure. .SH NOTATION .LP An emacs\-style notation is used to denote keystrokes. Control keys are denoted by C\-\fIkey\fR, e.g., C\-n means Control\-N. Similarly, .I meta keys are denoted by M\-\fIkey\fR, so M\-x means Meta\-X. (On keyboards without a .I meta key, M\-\fIx\fP means ESC \fIx\fP, i.e., press the Escape key then the .I x key. This makes ESC the \fImeta prefix\fP. The combination M\-C\-\fIx\fP means ESC\-Control\-\fIx\fP, or press the Escape key then hold the Control key while pressing the .I x key.) .PP Readline commands may be given numeric .IR arguments , which normally act as a repeat count. Sometimes, however, it is the sign of the argument that is significant. Passing a negative argument to a command that acts in the forward direction (e.g., \fBkill\-line\fP) causes that command to act in a backward direction. Commands whose behavior with arguments deviates from this are noted. .PP When a command is described as \fIkilling\fP text, the text deleted is saved for possible future retrieval (\fIyanking\fP). The killed text is saved in a \fIkill\-ring\fP. Consecutive kills cause the text to be accumulated into one unit, which can be yanked all at once. Commands which do not kill text separate the chunks of text on the kill\-ring. .SH INITIALIZATION FILE .LP Readline is customized by putting commands in an initialization file. The name of this file is taken from the value of the .B INPUTRC variable. If that variable is unset, the default is .IR ~/.inputrc . When a program which uses the readline library starts up, the init file is read, and the key bindings and variables are set. There are only a few basic constructs allowed in the readline init file. Blank lines are ignored. Lines beginning with a \fB#\fP are comments. Lines beginning with a \fB$\fP indicate conditional constructs. Other lines denote key bindings and variable settings. Each program using this library may add its own commands and bindings. .PP For example, placing .RS .PP M\-Control\-u: universal\-argument .RE or .RS C\-Meta\-u: universal\-argument .RE into the .FN ~/.inputrc would make M\-C\-u execute the readline command .IR universal\-argument . .PP The following symbolic character names are recognized while processing key bindings: .IR RUBOUT , .IR DEL , .IR ESC , .IR LFD , .IR NEWLINE , .IR RET , .IR RETURN , .IR SPC , .IR SPACE , and .IR TAB . In addition to command names, readline allows keys to be bound to a string that is inserted when the key is pressed (a \fImacro\fP). .PP .SS Key Bindings .PP The syntax for controlling key bindings in the .I ~/.inputrc file is simple. All that is required is the name of the command or the text of a macro and a key sequence to which it should be bound. The name may be specified in one of two ways: as a symbolic key name, possibly with \fIMeta\-\fP or \fIControl\-\fP prefixes, or as a key sequence. When using the form \fBkeyname\fP:\fIfunction-name\fP or \fImacro\fP, .I keyname is the name of a key spelled out in English. For example: .sp .RS Control\-u: universal\-argument .br Meta\-Rubout: backward\-kill\-word .br Control\-o: ">&output" .RE .LP In the above example, .I C\-u is bound to the function .BR universal\-argument , .I M-DEL is bound to the function .BR backward\-kill\-word , and .I C\-o is bound to run the macro expressed on the right hand side (that is, to insert the text .I >&output into the line). .PP In the second form, \fB"keyseq"\fP:\fIfunction\-name\fP or \fImacro\fP, .B keyseq differs from .B keyname above in that strings denoting an entire key sequence may be specified by placing the sequence within double quotes. Some GNU Emacs style key escapes can be used, as in the following example. .sp .RS "\eC\-u": universal\-argument .br "\eC\-x\eC\-r": re\-read\-init\-file .br "\ee[11~": "Function Key 1" .RE .PP In this example, .I C-u is again bound to the function .BR universal\-argument . .I "C-x C-r" is bound to the function .BR re\-read\-init\-file , and .I "ESC [ 1 1 ~" is bound to insert the text .BR "Function Key 1" . The full set of escape sequences is .RS .TP .B \eC- control prefix .TP .B \eM- meta prefix .TP .B \ee an escape character .TP .B \e\e backslash .TP .B \e" literal " .TP .B \e' literal ' .RE .PP When entering the text of a macro, single or double quotes should be used to indicate a macro definition. Unquoted text is assumed to be a function name. Backslash will quote any character in the macro text, including " and '. .PP .B Bash allows the current readline key bindings to be displayed or modified with the .B bind builtin command. The editing mode may be switched during interactive use by using the .B \-o option to the .B set builtin command. Other programs using this library provide similar mechanisms. The .I inputrc file may be edited and re\-read if a program does not provide any other means to incorporate new bindings. .SS Variables .PP Readline has variables that can be used to further customize its behavior. A variable may be set in the .I inputrc file with a statement of the form .RS .PP \fBset\fP \fIvariable\-name\fP \fIvalue\fP .RE .PP Except where noted, readline variables can take the values .B On or .BR Off . The variables and their default values are: .PP .PD 0 .TP .B horizontal\-scroll\-mode (Off) When set to \fBOn\fP, makes readline use a single line for display, scrolling the input horizontally on a single screen line when it becomes longer than the screen width rather than wrapping to a new line. .TP .B editing\-mode (emacs) Controls whether readline begins with a set of key bindings similar to \fIemacs\fP or \fIvi\fP. .B editing\-mode can be set to either .B emacs or .BR vi . .TP .B mark\-modified\-lines (Off) If set to \fBOn\fP, history lines that have been modified are displayed with a preceding asterisk (\fB*\fP). .TP .B bell\-style (audible) Controls what happens when readline wants to ring the terminal bell. If set to \fBnone\fP, readline never rings the bell. If set to \fBvisible\fP, readline uses a visible bell if one is available. If set to \fBaudible\fP, readline attempts to ring the terminal's bell. .TP .B comment\-begin (``#'') The string that is inserted in \fBvi\fP mode when the .B vi\-comment command is executed. .TP .B meta\-flag (Off) If set to \fBOn\fP, readline will enable eight-bit input (that is, it will not strip the high bit from the characters it reads), regardless of what the terminal claims it can support. .TP .B convert\-meta (On) If set to \fBOn\fP, readline will convert characters with the eighth bit set to an ASCII key sequence by stripping the eighth bit and prepending an escape character (in effect, using escape as the \fImeta prefix\fP). .TP .B output\-meta (Off) If set to \fBOn\fP, readline will display characters with the eighth bit set directly rather than as a meta-prefixed escape sequence. .TP .B completion\-query\-items (100) This determines when the user is queried about viewing the number of possible completions generated by the \fBpossible\-completions\fP command. It may be set to any integer value greater than or equal to zero. If the number of possible completions is greater than or equal to the value of this variable, the user is asked whether or not he wishes to view them; otherwise they are simply listed on the terminal. .TP .B keymap (emacs) Set the current readline keymap. The set of legal keymap names is \fIemacs, emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move, vi-command\fP, and .IR vi-insert . \fIvi\fP is equivalent to \fIvi-command\fP; \fIemacs\fP is equivalent to \fIemacs-standard\fP. The default value is .IR emacs ; the value of .B editing\-mode also affects the default keymap. .TP .B show\-all\-if\-ambiguous (Off) This alters the default behavior of the completion functions. If set to .BR on , words which have more than one possible completion cause the matches to be listed immediately instead of ringing the bell. .TP .B expand\-tilde (Off) If set to \fBon\fP, tilde expansion is performed when readline attempts word completion. .PD .SS Conditional Constructs .PP Readline implements a facility similar in spirit to the conditional compilation features of the C preprocessor which allows key bindings and variable settings to be performed as the result of tests. There are three parser directives used. .IP \fB$if\fP The .B $if construct allows bindings to be made based on the editing mode, the terminal being used, or the application using readline. The text of the test extends to the end of the line; no characters are required to isolate it. .RS .IP \fBmode\fP The \fBmode=\fP form of the \fB$if\fP directive is used to test whether readline is in emacs or vi mode. This may be used in conjunction with the \fBset keymap\fP command, for instance, to set bindings in the \fIemacs-standard\fP and \fIemacs-ctlx\fP keymaps only if readline is starting out in emacs mode. .IP \fBterm\fP The \fBterm=\fP form may be used to include terminal-specific key bindings, perhaps to bind the key sequences output by the terminal's function keys. The word on the right side of the .B = is tested against the full name of the terminal and the portion of the terminal name before the first \fB\-\fP. This allows .I sun to match both .I sun and .IR sun\-cmd , for instance. .IP \fBapplication\fP The \fBapplication\fP construct is used to include application\-specific settings. Each program using the readline library sets the \fIapplication name\fP, and an initialization file can test for a particular value. This could be used to bind key sequences to functions useful for a specific program. For instance, the following command adds a key sequence that quotes the current or previous word in Bash: .RS .nf \fB$if\fP bash # Quote the current or previous word "\eC-xq": "\eeb\e"\eef\e"" \fB$endif\fP .fi .RE .RE .IP \fB$endif\fP This command, as you saw in the previous example, terminates an \fB$if\fP command. .IP \fB$else\fP Commands in this branch of the \fB$if\fP directive are executed if the test fails. .SH EDITING COMMANDS .PP The following is a list of the names of the commands and the default key sequences to which they are bound. .SS Commands for Moving .PP .PD 0 .TP .B beginning\-of\-line (C\-a) Move to the start of the current line. .TP .B end\-of\-line (C\-e) Move to the end of the line. .TP .B forward\-char (C\-f) Move forward a character. .TP .B backward\-char (C\-b) Move back a character. .TP .B forward\-word (M\-f) Move forward to the end of the next word. Words are composed of alphanumeric characters (letters and digits). .TP .B backward\-word (M\-b) Move back to the start of this, or the previous, word. Words are composed of alphanumeric characters (letters and digits). .TP .B clear\-screen (C\-l) Clear the screen leaving the current line at the top of the screen. With an argument, refresh the current line without clearing the screen. .TP .B redraw\-current\-line Refresh the current line. By default, this is unbound. .PD .SS Commands for Manipulating the History .PP .PD 0 .TP .B accept\-line (Newline, Return) Accept the line regardless of where the cursor is. If this line is non\-empty, add it to the history list. If the line is a modified history line, then restore the history line to its original state. .TP .B previous\-history (C\-p) Fetch the previous command from the history list, moving back in the list. .TP .B next\-history (C\-n) Fetch the next command from the history list, moving forward in the list. .TP .B beginning\-of\-history (M\-<) Move to the first line in the history. .TP .B end\-of\-history (M\->) Move to the end of the input history, i.e., the line currently being entered. .TP .B reverse\-search\-history (C\-r) Search backward starting at the current line and moving `up' through the history as necessary. This is an incremental search. .TP .B forward\-search\-history (C\-s) Search forward starting at the current line and moving `down' through the history as necessary. This is an incremental search. .TP .B non\-incremental\-reverse\-search\-history (M\-p) Search backward through the history starting at the current line using a non\-incremental search for a string supplied by the user. .TP .B non\-incremental\-forward\-search\-history (M\-n) Search forward through the history using a non\-incremental search for a string supplied by the user. .TP .B history\-search\-forward Search forward through the history for the string of characters between the start of the current line and the current point. This is a non-incremental search. By default, this command is unbound. .TP .B history\-search\-backward Search backward through the history for the string of characters between the start of the current line and the current point. This is a non-incremental search. By default, this command is unbound. .TP .B yank\-nth\-arg (M\-C\-y) Insert the first argument to the previous command (usually the second word on the previous line) at point (the current cursor position). With an argument .IR n , insert the \fIn\fPth word from the previous command (the words in the previous command begin with word 0). A negative argument inserts the \fIn\fPth word from the end of the previous command. .PD .SS Commands for Changing Text .PP .PD 0 .TP .B delete\-char (C\-d) Delete the character under the cursor. If point is at the beginning of the line, there are no characters in the line, and the last character typed was not .BR C\-d , then return .SM .BR EOF . .TP .B backward\-delete\-char (Rubout) Delete the character behind the cursor. When given a numeric argument, save the deleted text on the kill\-ring. .TP .B quoted\-insert (C\-q, C\-v) Add the next character that you type to the line verbatim. This is how to insert characters like \fBC\-q\fP, for example. .TP .B tab\-insert (M-TAB) Insert a tab character. .TP .B self\-insert (a,\ b,\ A,\ 1,\ !,\ ...) Insert the character typed. .TP .B transpose\-chars (C\-t) Drag the character before point forward over the character at point. Point moves forward as well. If point is at the end of the line, then transpose the two characters before point. Negative arguments don't work. .TP .B transpose\-words (M\-t) Drag the word behind the cursor past the word in front of the cursor moving the cursor over that word as well. .TP .B upcase\-word (M\-u) Uppercase the current (or following) word. With a negative argument, do the previous word, but do not move point. .TP .B downcase\-word (M\-l) Lowercase the current (or following) word. With a negative argument, do the previous word, but do not move point. .TP .B capitalize\-word (M\-c) Capitalize the current (or following) word. With a negative argument, do the previous word, but do not move point. .PD .SS Killing and Yanking .PP .PD 0 .TP .B kill\-line (C\-k) Kill the text from the current cursor position to the end of the line. .TP .B backward\-kill\-line (C\-x Rubout) Kill backward to the beginning of the line. .TP .B unix\-line\-discard (C\-u) Kill backward from point to the beginning of the line. .\" There is no real difference between this and backward-kill-line .TP .B kill\-whole\-line Kill all characters on the current line, no matter where the cursor is. By default, this is unbound. .TP .B kill\-word (M\-d) Kill from the cursor to the end of the current word, or if between words, to the end of the next word. Word boundaries are the same as those used by \fBforward\-word\fP. .TP .B backward\-kill\-word (M\-Rubout) Kill the word behind the cursor. Word boundaries are the same as those used by \fBbackward\-word\fP. .TP .B unix\-word\-rubout (C\-w) Kill the word behind the cursor, using white space as a word boundary. The word boundaries are different from .BR backward\-kill\-word . .TP .B delete\-horizontal\-space Delete all spaces and tabs around point. By default, this is unbound. .TP .B yank (C\-y) Yank the top of the kill ring into the buffer at the cursor. .TP .B yank\-pop (M\-y) Rotate the kill\-ring, and yank the new top. Only works following .B yank or .BR yank\-pop . .PD .SS Numeric Arguments .PP .PD 0 .TP .B digit\-argument (M\-0, M\-1, ..., M\-\-) Add this digit to the argument already accumulating, or start a new argument. M\-\- starts a negative argument. .TP .B universal\-argument Each time this is executed, the argument count is multiplied by four. The argument count is initially one, so executing this function the first time makes the argument count four. By default, this is not bound to a key. .PD .SS Completing .PP .PD 0 .TP .B complete (TAB) Attempt to perform completion on the text before point. The actual completion performed is application-specific. .BR Bash , for instance, attempts completion treating the text as a variable (if the text begins with \fB$\fP), username (if the text begins with \fB~\fP), hostname (if the text begins with \fB@\fP), or command (including aliases and functions) in turn. If none of these produces a match, filename completion is attempted. .BR Gdb , on the other hand, allows completion of program functions and variables, and only attempts filename completion under certain circumstances. .TP .B possible\-completions (M-?) List the possible completions of the text before point. .TP .B insert\-completions Insert all completions of the text before point that would have been generated by \fBpossible\-completions\fP. By default, this is not bound to a key. .PD .SS Keyboard Macros .PP .PD 0 .TP .B start\-kbd\-macro (C-x (\^) Begin saving the characters typed into the current keyboard macro. .TP .B end\-kbd\-macro (C-x )\^) Stop saving the characters typed into the current keyboard macro and save the definition. .TP .B call\-last\-kbd\-macro (C-x e) Re-execute the last keyboard macro defined, by making the characters in the macro appear as if typed at the keyboard. .PD .SS Miscellaneous .PP .PD 0 .TP .B re-read-init-file (C\-x C\-r) Read in the contents of your init file, and incorporate any bindings or variable assignments found there. .TP .B abort (C\-g) Abort the current editing command and ring the terminal's bell (subject to the setting of .BR bell\-style ). .TP .B do\-uppercase\-version (M\-a, M\-b, ...) Run the command that is bound to the corresponding uppercase character. .TP .B prefix\-meta (ESC) Metafy the next character typed. .SM .B ESC .B f is equivalent to .BR Meta\-f . .TP .B undo (C\-_, C\-x C\-u) Incremental undo, separately remembered for each line. .TP .B revert\-line (M\-r) Undo all changes made to this line. This is like typing the .B undo command enough times to return the line to its initial state. .TP .B tilde\-expand (M\-~) Perform tilde expansion on the current word. .TP .B dump\-functions Print all of the functions and their key bindings to the readline output stream. If a numeric argument is supplied, the output is formatted in such a way that it can be made part of an \fIinputrc\fP file. .TP .B emacs\-editing\-mode (C\-e) When in .B vi editing mode, this causes a switch to .B emacs editing mode. .TP .B vi\-editing\-mode (M\-C\-j) When in .B emacs editing mode, this causes a switch to .B vi editing mode. .PD .SH DEFAULT KEY BINDINGS .LP The following is a list of the default emacs and vi bindings. Characters with the 8th bit set are written as M-, and are referred to as .I metafied characters. The printable ASCII characters not mentioned in the list of emacs standard bindings are bound to the .I self\-insert function, which just inserts the given character into the input line. In vi insertion mode, all characters not specifically mentioned are bound to .IR self\-insert . Characters assigned to signal generation by .IR stty (1) or the terminal driver, such as C-Z or C-C, retain that function. Upper and lower case .I metafied characters are bound to the same function in the emacs mode meta keymap. The remaining characters are unbound, which causes readline to ring the bell (subject to the setting of the .B bell\-style variable). .SS Emacs Mode .RS +.6i .nf .ta 2.5i .sp Emacs Standard bindings .sp "C-A" -> beginning-of-line "C-B" -> backward-char "C-D" -> delete-char "C-E" -> end-of-line "C-F" -> forward-char "C-G" -> abort "C-H" -> backward-delete-char "C-I" -> complete "C-J" -> accept-line "C-K" -> kill-line "C-L" -> clear-screen "C-M" -> accept-line "C-N" -> next-history "C-P" -> previous-history "C-Q" -> quoted-insert "C-R" -> reverse-search-history "C-S" -> forward-search-history "C-T" -> transpose-chars "C-U" -> unix-line-discard "C-V" -> quoted-insert "C-W" -> unix-word-rubout "C-Y" -> yank "C-_" -> undo "\^ " to "/" -> self-insert "0" to "9" -> self-insert ":" to "~" -> self-insert "C-?" -> backward-delete-char .PP Emacs Meta bindings .sp "M-C-H" -> backward-kill-word "M-C-I" -> tab-insert "M-C-J" -> vi-editing-mode "M-C-M" -> vi-editing-mode "M-C-R" -> revert-line "M-C-Y" -> yank-nth-arg "M-C-[" -> complete "M-&" -> tilde-expand "M--" -> digit-argument "M-0" -> digit-argument "M-1" -> digit-argument "M-2" -> digit-argument "M-3" -> digit-argument "M-4" -> digit-argument "M-5" -> digit-argument "M-6" -> digit-argument "M-7" -> digit-argument "M-8" -> digit-argument "M-9" -> digit-argument "M-<" -> beginning-of-history "M->" -> end-of-history "M-?" -> possible-completions "M-B" -> backward-word "M-C" -> capitalize-word "M-D" -> kill-word "M-F" -> forward-word "M-L" -> downcase-word "M-N" -> non-incremental-forward-search-history "M-O" -> arrow-key-prefix "M-P" -> non-incremental-reverse-search-history "M-R" -> revert-line "M-T" -> transpose-words "M-U" -> upcase-word "M-Y" -> yank-pop "M-C-Y" -> yank-nth-arg "M-C-?" -> backward-delete-word .PP Emacs Control-X bindings .sp "C-XC-G" -> abort "C-XC-R" -> re-read-init-file "C-XC-U" -> undo "C-X(" -> start-kbd-macro "C-X)" -> end-kbd-macro "C-Xe" -> call-last-kbd-macro "C-XC-?" -> backward-kill-line .sp .RE .SS VI Mode bindings .RS +.6i .nf .ta 2.5i .sp .PP VI Insert Mode functions .sp "C-D" -> vi-eof-maybe "C-H" -> backward-delete-char "C-I" -> complete "C-J" -> accept-line "C-K" -> kill-line "C-L" -> clear-screen "C-M" -> accept-line "C-N" -> next-history "C-P" -> previous-history "C-Q" -> quoted-insert "C-R" -> reverse-search-history "C-S" -> forward-search-history "C-T" -> transpose-chars "C-U" -> unix-line-discard "C-V" -> quoted-insert "C-W" -> unix-word-rubout "C-Y" -> yank "C-[" -> vi-movement-mode "\^ " to "~" -> self-insert "C-?" -> backward-delete-char .PP VI Command Mode functions .sp "C-D" -> vi-eof-maybe "C-E" -> emacs-editing-mode "C-G" -> abort "C-H" -> backward-char "C-J" -> accept-line "C-K" -> kill-line "C-L" -> clear-screen "C-M" -> accept-line "C-N" -> next-history "C-P" -> previous-history "C-Q" -> quoted-insert "C-R" -> reverse-search-history "C-S" -> forward-search-history "C-T" -> transpose-chars "C-U" -> unix-line-discard "C-V" -> quoted-insert "C-W" -> unix-word-rubout "C-Y" -> yank "C-[" -> abort "\^ " -> forward-char "#" -> vi-comment "$" -> end-of-line "%" -> vi-match "&" -> vi-tilde-expand "*" -> vi-complete "+" -> down-history "," -> vi-char-search "-" -> previous-history "." -> vi-redo "/" -> vi-search "0" -> beginning-of-line "1" to "9" -> vi-arg-digit ";" -> vi-char-search "=" -> vi-complete "?" -> vi-search "@" -> is undefined "A" -> vi-append-eol "B" -> vi-prev-word "C" -> vi-change-to "D" -> vi-delete-to "E" -> vi-end-word "F" -> vi-char-search "I" -> vi-insert-beg "N" -> vi-search-again "P" -> vi-put "R" -> vi-replace "S" -> vi-subst "T" -> vi-char-search "U" -> revert-line "W" -> vi-next-word "X" -> backward-delete-char "Y" -> vi-yank-to "\e" -> vi-complete "^" -> vi-first-print "_" -> vi-yank-arg "a" -> vi-append-mode "b" -> vi-prev-word "c" -> vi-change-to "d" -> vi-delete-to "e" -> vi-end-word "f" -> vi-char-search "h" -> backward-char "i" -> vi-insertion-mode "j" -> next-history "k" -> prev-history "l" -> forward-char "n" -> vi-search-again "r" -> vi-change-char "s" -> vi-subst "t" -> vi-char-search "u" -> undo "w" -> vi-next-word "x" -> vi-delete "y" -> vi-yank-to "|" -> vi-column "~" -> vi-change-case .RE .SH "SEE ALSO" .PD 0 .TP \fIThe Gnu Readline Library\fP, Brian Fox .TP \fIThe Gnu History Library\fP, Brian Fox .TP \fIbash\fP(1) .PD .SH FILES .PD 0 .TP .FN ~/.inputrc Individual \fBreadline\fP initialization file .PD .SH AUTHORS .RS Brian Fox, Free Software Foundation (primary author) .br bfox@ai.MIT.Edu .PP Chet Ramey, Case Western Reserve University .br chet@ins.CWRU.Edu .SH BUG REPORTS If you find a bug in .B readline, you should report it. But first, you should make sure that it really is a bug, and that it appears in the latest version of the .B readline library that you have. .PP Once you have determined that a bug actually exists, mail a bug report to \fIbash\-maintainers\fP@\fIprep.ai.MIT.Edu\fP. If you have a fix, you are welcome to mail that as well! Suggestions and `philosophical' bug reports may be mailed to \fPbug-bash\fP@\fIprep.ai.MIT.Edu\fP or posted to the Usenet newsgroup .BR gnu.bash.bug . .PP Comments and bug reports concerning this manual page should be directed to .IR chet@ins.CWRU.Edu . .SH BUGS .PP It's too big and too slow. eif/readline/doc/README000644 002123 000322 00000000162 05745515012 016246 0ustar00childrenpstaff000003 3110457 Complete documentation is available with the Readline-2.0 distribution from any GNU mirror (prep.ai.mit.edu etc). eif/readline/emacs_keymap.c000644 002123 000322 00000102453 05617733404 017434 0ustar00childrenpstaff000003 3027250 /* 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 */ }; eif/readline/examples000755 002123 000322 00000000000 05613273654 016363 5ustar00childrenpstaff000003 3302422 eif/readline/examples/Makefile000644 002123 000322 00000000365 05613033447 020101 0ustar00childrenpstaff000003 3302423 # This is the Makefile for the examples subdirectory of readline. -*- text -*- # EXECUTABLES = fileman CFLAGS = -g -I.. LDFLAGS = -g -L.. fileman: fileman.o $(CC) $(LDFLAGS) -o fileman fileman.o -lreadline -ltermcap fileman.o: fileman.c eif/readline/examples/fileman.c000644 002123 000322 00000022703 05617733571 020234 0ustar00childrenpstaff000003 3306350 /* fileman.c -- A tiny application which demonstrates how to use the GNU Readline library. This application interactively allows users to manipulate files and their modes. */ #include #include #include #include #include #include #include extern char *getwd (); extern char *xmalloc (); /* The names of functions that actually do the manipulation. */ int com_list (), com_view (), com_rename (), com_stat (), com_pwd (); int com_delete (), com_help (), com_cd (), com_quit (); /* A structure which contains information on the commands this program can understand. */ typedef struct { char *name; /* User printable name of the function. */ Function *func; /* Function to call to do the job. */ char *doc; /* Documentation for this function. */ } COMMAND; COMMAND commands[] = { { "cd", com_cd, "Change to directory DIR" }, { "delete", com_delete, "Delete FILE" }, { "help", com_help, "Display this text" }, { "?", com_help, "Synonym for `help'" }, { "list", com_list, "List files in DIR" }, { "ls", com_list, "Synonym for `list'" }, { "pwd", com_pwd, "Print the current working directory" }, { "quit", com_quit, "Quit using Fileman" }, { "rename", com_rename, "Rename FILE to NEWNAME" }, { "stat", com_stat, "Print out statistics on FILE" }, { "view", com_view, "View the contents of FILE" }, { (char *)NULL, (Function *)NULL, (char *)NULL } }; /* Forward declarations. */ char *stripwhite (); COMMAND *find_command (); /* The name of this program, as taken from argv[0]. */ char *progname; /* When non-zero, this global means the user is done using this program. */ int done; char * dupstr (s) int s; { char *r; r = xmalloc (strlen (s) + 1); strcpy (r, s); return (r); } main (argc, argv) int argc; char **argv; { char *line, *s; progname = argv[0]; initialize_readline (); /* Bind our completer. */ /* Loop reading and executing lines until the user quits. */ for ( ; done == 0; ) { line = readline ("FileMan: "); if (!line) break; /* Remove leading and trailing whitespace from the line. Then, if there is anything left, add it to the history list and execute it. */ s = stripwhite (line); if (*s) { add_history (s); execute_line (s); } free (line); } exit (0); } /* Execute a command line. */ int execute_line (line) char *line; { register int i; COMMAND *command; char *word; /* Isolate the command word. */ i = 0; while (line[i] && whitespace (line[i])) i++; word = line + i; while (line[i] && !whitespace (line[i])) i++; if (line[i]) line[i++] = '\0'; command = find_command (word); if (!command) { fprintf (stderr, "%s: No such command for FileMan.\n", word); return (-1); } /* Get argument to command, if any. */ while (whitespace (line[i])) i++; word = line + i; /* Call the function. */ return ((*(command->func)) (word)); } /* Look up NAME as the name of a command, and return a pointer to that command. Return a NULL pointer if NAME isn't a command name. */ COMMAND * find_command (name) char *name; { register int i; for (i = 0; commands[i].name; i++) if (strcmp (name, commands[i].name) == 0) return (&commands[i]); return ((COMMAND *)NULL); } /* Strip whitespace from the start and end of STRING. Return a pointer into STRING. */ char * stripwhite (string) char *string; { register char *s, *t; for (s = string; whitespace (*s); s++) ; if (*s == 0) return (s); t = s + strlen (s) - 1; while (t > s && whitespace (*t)) t--; *++t = '\0'; return s; } /* **************************************************************** */ /* */ /* Interface to Readline Completion */ /* */ /* **************************************************************** */ char *command_generator (); char **fileman_completion (); /* Tell the GNU Readline library how to complete. We want to try to complete on command names if this is the first word in the line, or on filenames if not. */ initialize_readline () { /* Allow conditional parsing of the ~/.inputrc file. */ rl_readline_name = "FileMan"; /* Tell the completer that we want a crack first. */ rl_attempted_completion_function = (CPPFunction *)fileman_completion; } /* Attempt to complete on the contents of TEXT. START and END show the region of TEXT that contains the word to complete. We can use the entire line in case we want to do some simple parsing. Return the array of matches, or NULL if there aren't any. */ char ** fileman_completion (text, start, end) char *text; int start, end; { char **matches; matches = (char **)NULL; /* If this word is at the start of the line, then it is a command to complete. Otherwise it is the name of a file in the current directory. */ if (start == 0) matches = completion_matches (text, command_generator); return (matches); } /* Generator function for command completion. STATE lets us know whether to start from scratch; without any state (i.e. STATE == 0), then we start at the top of the list. */ char * command_generator (text, state) char *text; int state; { static int list_index, len; char *name; /* If this is a new word to complete, initialize now. This includes saving the length of TEXT for efficiency, and initializing the index variable to 0. */ if (!state) { list_index = 0; len = strlen (text); } /* Return the next name which partially matches from the command list. */ while (name = commands[list_index].name) { list_index++; if (strncmp (name, text, len) == 0) return (dupstr(name)); } /* If no names matched, then return NULL. */ return ((char *)NULL); } /* **************************************************************** */ /* */ /* FileMan Commands */ /* */ /* **************************************************************** */ /* String to pass to system (). This is for the LIST, VIEW and RENAME commands. */ static char syscom[1024]; /* List the file(s) named in arg. */ com_list (arg) char *arg; { if (!arg) arg = ""; sprintf (syscom, "ls -FClg %s", arg); return (system (syscom)); } com_view (arg) char *arg; { if (!valid_argument ("view", arg)) return 1; sprintf (syscom, "more %s", arg); return (system (syscom)); } com_rename (arg) char *arg; { too_dangerous ("rename"); return (1); } com_stat (arg) char *arg; { struct stat finfo; if (!valid_argument ("stat", arg)) return (1); if (stat (arg, &finfo) == -1) { perror (arg); return (1); } printf ("Statistics for `%s':\n", arg); printf ("%s has %d link%s, and is %d byte%s in length.\n", arg, finfo.st_nlink, (finfo.st_nlink == 1) ? "" : "s", finfo.st_size, (finfo.st_size == 1) ? "" : "s"); printf ("Inode Last Change at: %s", ctime (&finfo.st_ctime)); printf (" Last access at: %s", ctime (&finfo.st_atime)); printf (" Last modified at: %s", ctime (&finfo.st_mtime)); return (0); } com_delete (arg) char *arg; { too_dangerous ("delete"); return (1); } /* Print out help for ARG, or for all of the commands if ARG is not present. */ com_help (arg) char *arg; { register int i; int printed = 0; for (i = 0; commands[i].name; i++) { if (!*arg || (strcmp (arg, commands[i].name) == 0)) { printf ("%s\t\t%s.\n", commands[i].name, commands[i].doc); printed++; } } if (!printed) { printf ("No commands match `%s'. Possibilties are:\n", arg); for (i = 0; commands[i].name; i++) { /* Print in six columns. */ if (printed == 6) { printed = 0; printf ("\n"); } printf ("%s\t", commands[i].name); printed++; } if (printed) printf ("\n"); } return (0); } /* Change to the directory ARG. */ com_cd (arg) char *arg; { if (chdir (arg) == -1) { perror (arg); return 1; } com_pwd (""); return (0); } /* Print out the current working directory. */ com_pwd (ignore) char *ignore; { char dir[1024], *s; s = getwd (dir); if (s == 0) { printf ("Error getting pwd: %s\n", dir); return 1; } printf ("Current directory is %s\n", dir); return 0; } /* The user wishes to quit using this program. Just set DONE non-zero. */ com_quit (arg) char *arg; { done = 1; return (0); } /* Function which tells you that you can't do this. */ too_dangerous (caller) char *caller; { fprintf (stderr, "%s: Too dangerous for me to distribute. Write it yourself.\n", caller); } /* Return non-zero if ARG is a valid argument for CALLER, else print an error message and return zero. */ int valid_argument (caller, arg) char *caller, *arg; { if (!arg || !*arg) { fprintf (stderr, "%s: Argument required.\n", caller); return (0); } return (1); } eif/readline/examples/manexamp.c000644 002123 000322 00000004617 05617733572 020427 0ustar00childrenpstaff000003 3304230 /* manexamp.c -- The examples which appear in the documentation are here. */ #include #include /* **************************************************************** */ /* */ * How to Emulate gets () */ /* */ /* **************************************************************** */ /* A static variable for holding the line. */ static char *line_read = (char *)NULL; /* Read a string, and return a pointer to it. Returns NULL on EOF. */ char * rl_gets () { /* If the buffer has already been allocated, return the memory to the free pool. */ if (line_read) { free (line_read); line_read = (char *)NULL; } /* Get a line from the user. */ line_read = readline (""); /* If the line has any text in it, save it on the history. */ if (line_read && *line_read) add_history (line_read); return (line_read); } /* **************************************************************** */ /* */ /* Writing a Function to be Called by Readline. */ /* */ /* **************************************************************** */ /* Invert the case of the COUNT following characters. */ invert_case_line (count, key) int count, key; { register int start, end; start = rl_point; if (count < 0) { direction = -1; count = -count; } else direction = 1; /* Find the end of the range to modify. */ end = start + (count * direction); /* Force it to be within range. */ if (end > rl_end) end = rl_end; else if (end < 0) end = -1; if (start > end) { int temp = start; start = end; end = temp; } if (start == end) return; /* Tell readline that we are modifying the line, so save the undo information. */ rl_modifying (start, end); for (; start != end; start += direction) { if (uppercase_p (rl_line_buffer[start])) rl_line_buffer[start] = to_lower (rl_line_buffer[start]); else if (lowercase_p (rl_line_buffer[start])) rl_line_buffer[start] = to_upper (rl_line_buffer[start]); } /* Move point to on top of the last character changed. */ rl_point = end - direction; } eif/readline/examples/Inputrc000644 002123 000322 00000003154 05615524052 020011 0ustar00childrenpstaff000003 3304460 # My ~/.inputrc file is in -*- text -*- for easy editing with Emacs. # # Notice the various bindings which are conditionalized depending # on which program is running, or what terminal is active. # # In all programs, all terminals, make sure this is bound. "\C-x\C-r": re-read-init-file # Hp terminals (and some others) have ugly default behaviour for C-h. "\C-h": backward-delete-char "\e\C-h": backward-kill-word "\C-xd": dump-functions # In xterm windows, make the arrow keys do the right thing. $if TERM=xterm "\e[A": previous-history "\e[B": next-history "\e[C": forward-char "\e[D": backward-char # alternate arrow key prefix "\eOA": previous-history "\eOB": next-history "\eOC": forward-char "\eOD": backward-char # Under Xterm in Bash, we bind local Function keys to do something useful. $if Bash "\e[11~": "Function Key 1" "\e[12~": "Function Key 2" "\e[13~": "Function Key 3" "\e[14~": "Function Key 4" "\e[15~": "Function Key 5" # I know the following escape sequence numbers are 1 greater than # the function key. Don't ask me why, I didn't design the xterm terminal. "\e[17~": "Function Key 6" "\e[18~": "Function Key 7" "\e[19~": "Function Key 8" "\e[20~": "Function Key 9" "\e[21~": "Function Key 10" $endif $endif # For Bash, all terminals, add some Bash specific hacks. $if Bash "\C-xv": show-bash-version "\C-x\C-e": shell-expand-line # Here is one for editing my path. "\C-xp": "$PATH\C-x\C-e\C-e\"\C-aPATH=\":\C-b" # Make C-x r read my mail in emacs. # "\C-xr": "emacs -f rmail\C-j" $endif # For FTP, different hacks: $if Ftp "\C-xg": "get \M-?" "\C-xt": "put \M-?" "\M-.": yank-last-arg $endif " ": self-insert eif/readline/examples/histexamp.c000644 002123 000322 00000003672 05617733572 020632 0ustar00childrenpstaff000003 3304462 main () { char line[1024], *t; int len, done = 0; line[0] = 0; using_history (); while (!done) { printf ("history$ "); fflush (stdout); t = fgets (line, sizeof (line) - 1, stdin); if (t && *t) { len = strlen (t); if (t[len - 1] == '\n') t[len - 1] = '\0'; } if (!t) strcpy (line, "quit"); if (line[0]) { char *expansion; int result; using_history (); result = history_expand (line, &expansion); if (result) fprintf (stderr, "%s\n", expansion); if (result < 0 || result == 2) { free (expansion); continue; } add_history (expansion); strncpy (line, expansion, sizeof (line) - 1); free (expansion); } if (strcmp (line, "quit") == 0) done = 1; else if (strcmp (line, "save") == 0) write_history ("history_file"); else if (strcmp (line, "read") == 0) read_history ("history_file"); else if (strcmp (line, "list") == 0) { register HIST_ENTRY **the_list; register int i; the_list = history_list (); if (the_list) for (i = 0; the_list[i]; i++) printf ("%d: %s\n", i + history_base, the_list[i]->line); } else if (strncmp (line, "delete", 6) == 0) { int which; if ((sscanf (line + 6, "%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"); } } } } eif/readline/funmap.c000644 002123 000322 00000021724 05617733404 016263 0ustar00childrenpstaff000003 3027320 /* 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 */ eif/readline/history.c000644 002123 000322 00000144610 05617733404 016503 0ustar00childrenpstaff000003 3027370 /* 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: */ eif/readline/history.h000644 002123 000322 00000015074 05617733404 016476 0ustar00childrenpstaff000003 3013031 /* 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; eif/readline/isearch.c000644 002123 000322 00000023057 05617733404 016412 0ustar00childrenpstaff000003 3031440 /* **************************************************************** */ /* */ /* 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; } eif/readline/keymaps.c000644 002123 000322 00000010644 05617733405 016453 0ustar00childrenpstaff000003 3035740 /* 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 */ eif/readline/keymaps.h000644 002123 000322 00000006232 05617733405 016450 0ustar00childrenpstaff000003 3036112 /* 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_ */ eif/readline/memalloc.h000644 002123 000322 00000003205 05617733405 016571 0ustar00childrenpstaff000003 3035234 /* 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__ */ eif/readline/parens.c000644 002123 000322 00000006600 05617733405 016260 0ustar00childrenpstaff000003 3036210 /* 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 */ eif/readline/posixstat.h000644 002123 000322 00000010741 05617733405 017041 0ustar00childrenpstaff000003 3036350 /* 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 */ eif/readline/readline.c000644 002123 000322 00000233711 05617733405 016562 0ustar00childrenpstaff000003 3031460 /* 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'. */ extern 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: */ eif/readline/readline.h000644 002123 000322 00000027306 05617733405 016566 0ustar00childrenpstaff000003 3031530 /* 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_ */ eif/readline/MANIFEST000644 002123 000322 00000001324 05613036224 015756 0ustar00childrenpstaff000003 3035745 doc 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 eif/readline/rlconf.h000644 002123 000322 00000004037 05617733405 016270 0ustar00childrenpstaff000003 3035613 /* 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_ */ eif/readline/rldefs.h000644 002123 000322 00000014737 05617733405 016271 0ustar00childrenpstaff000003 3017340 /* 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_BSD_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 */ eif/readline/rltty.c000644 002123 000322 00000040053 05617733405 016146 0ustar00childrenpstaff000003 3031620 /* 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 */ } eif/readline/search.c000644 002123 000322 00000021673 05617733405 016242 0ustar00childrenpstaff000003 3032050 /* 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)); } eif/readline/signals.c000644 002123 000322 00000016556 05617733405 016441 0ustar00childrenpstaff000003 3032230 /* 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 */ eif/readline/tilde.c000644 002123 000322 00000022620 05617733405 016067 0ustar00childrenpstaff000003 3032320 /* 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" #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 */ eif/readline/tilde.h000644 002123 000322 00000002627 05617733405 016107 0ustar00childrenpstaff000003 3036214 /* 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__ */ eif/readline/vi_keymap.c000644 002123 000322 00000100263 05617733405 016753 0ustar00childrenpstaff000003 3032330 /* 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 eif/readline/vi_mode.c000644 002123 000322 00000066273 05617733406 016432 0ustar00childrenpstaff000003 3032370 /* 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 */ eif/readline/xmalloc.c000644 002123 000322 00000004111 05617733406 016424 0ustar00childrenpstaff000003 3040270 /* 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 */ eif/readline/acconfig.h000644 002123 000322 00000001720 05612776050 016543 0ustar00childrenpstaff000003 3051052 /* 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). */ eif/readline/config.h.in000644 002123 000322 00000003616 05612774374 016671 0ustar00childrenpstaff000003 3037254 /* 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 eif/readline/configure000755 002123 000322 00000111041 05617767657 016546 0ustar00childrenpstaff000003 3032420 #!/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 # Make sure to not get the incompatible SysV /etc/install and # /usr/sbin/install, which might be in PATH before a BSD-like install, # or the SunOS /usr/etc/install directory, or the AIX /bin/install, # or the AFS install, which mishandles nonexistent args, or # /usr/ucb/install on SVR4, which tries to use the nonexistent group # `staff', or /sbin/install on IRIX which has incompatible command-line # syntax. Sigh. # # On most BSDish systems install is in /usr/bin, not /usr/ucb # anyway. # This turns out not to be true, so the mere pathname isn't an indication # of whether the program works. What we really need is a set of tests for # the install program to see if it actually works in all the required ways. # # Avoid using ./install, which might have been erroneously created # by make from ./install.sh. if test -z "${INSTALL}"; then test -n "$silent" || echo "checking for a BSD compatible install" IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do case "$ac_dir" in ''|.|/etc|/sbin|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. for ac_prog in installbsd scoinst install; do if test -f $ac_dir/$ac_prog; then if test $ac_prog = install && grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. # OSF/1 installbsd also uses dspmsg, but is usable. : else INSTALL="$ac_dir/$ac_prog -c" break 2 fi fi done ;; esac done IFS="$ac_save_ifs" fi if test -z "$INSTALL"; then # As a last resort, use the slow shell script. for ac_dir in ${srcdir} ${srcdir}/.. ${srcdir}/../..; do if test -f $ac_dir/install.sh; then INSTALL="$ac_dir/install.sh -c"; break fi done fi if test -z "$INSTALL"; then echo "configure: can not find install.sh in ${srcdir} or ${srcdir}/.. or ${srcdir}/../.." >&2; exit 1 fi test -n "$verbose" && echo " setting INSTALL to $INSTALL" # Use test -z because SunOS4 sh mishandles ${INSTALL_PROGRAM-'${INSTALL}'}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM" test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA" 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 eif/readline/configure.in000644 002123 000322 00000002401 05612777652 017155 0ustar00childrenpstaff000003 3037556 dnl 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]) eif/readline/INSTALL000644 002123 000322 00000013655 05613026122 015646 0ustar00childrenpstaff000003 3041500 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'. eif/readline/config.status000755 002123 000322 00000017574 05745300707 017356 0ustar00childrenpstaff000003 3032470 #!/bin/sh # Generated automatically by configure. # Run this file to recreate the current configuration. # This directory was configured as follows, # on host RedDragon.Empire.Net: # # ./configure 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} ./configure --no-create exec ${CONFIG_SHELL-/bin/sh} ./configure --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='gcc' CFLAGS='-g -O' LDFLAGS='' CPP='/lib/cpp' INSTALL='/usr/bin/installbsd -c' INSTALL_PROGRAM='${INSTALL}' INSTALL_DATA='${INSTALL} -m 644' RANLIB='ranlib' ALLOCA='' LIBS='' srcdir='.' top_srcdir='' prefix='/usr/local' exec_prefix='${prefix}' ac_prsub='' ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' extrasub='' 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 cat >> conftest.sed <> conftest.sed <> conftest.sed <> conftest.sed <> conftest.sed <> 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 eif/readline/Makefile000644 002123 000322 00000013626 05745300707 016272 0ustar00childrenpstaff000003 3042270 # Generated automatically from Makefile.in by configure. # 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 = . prefix = /usr/local exec_prefix = $(prefix) bindir = $(exec_prefix)/bin libdir = $(exec_prefix)/lib mandir = $(prefix)/man/man1 SHELL = /bin/sh INSTALL = /usr/bin/installbsd -c INSTALL_PROGRAM = ${INSTALL} INSTALL_DATA = ${INSTALL} -m 644 RANLIB = ranlib AR = ar RM = rm CP = cp MV = mv DEFS = -DHAVE_CONFIG_H CFLAGS = -g LDFLAGS = -g # 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 eif/readline/stamp-config000644 002123 000322 00000000000 05745300711 017010 0ustar00childrenpstaff000000 000000 eif/readline/config.h000644 002123 000322 00000004035 05745300710 016235 0ustar00childrenpstaff000003 3040273 /* config.h. Generated automatically by configure. */ /* 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). */ #define HAVE_ALLOCA_H 1 /* 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. */ #define GWINSZ_IN_SYS_IOCTL 1 /* #undef HAVE_GETPW_DECLS */ /* #undef NO_SYS_FILE */ /* Define if you have strcasecmp. */ #define HAVE_STRCASECMP 1 /* Define if you have the header file. */ #define HAVE_ALLOCA_H 1 /* Define if you have the header file. */ #define HAVE_DIRENT_H 1 /* Define if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define if you have the header file. */ #define HAVE_STRING_H 1 /* 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. */ #define HAVE_SYS_STREAM_H 1 /* Define if you have the header file. */ /* #undef HAVE_TERMCAP_H */ /* Define if you have the header file. */ #define HAVE_TERMIO_H 1 /* Define if you have the header file. */ #define HAVE_UNISTD_H 1 /* Define if you have the header file. */ #define HAVE_VARARGS_H 1 #endif eif/EXAMPLE.eifrc000644 002123 000322 00000002415 05023466732 015145 0ustar00childrenpstaff000001 3011176 # games addgame g1 localhost 1618 POGO peter gamedatadirectory1 addgame g2 localhost 1617 POGO peter gamedatadirectory2 # Expansion aliases alias d- "desi # ?des=- +" alias c- "cen # ?dis=0&foo<10" # dumping aliases alias dd "dump # ?des#. >!dmp" alias mm "map # >!map" alias dm "dd ; mm" alias ss "ship * >!ship" alias rr "radar #0 ?des=) >!r1" alias cc "coast #0 >!coast" alias rd "res #0 ?des=${1:-g}" # I hate mistyping move alias mvoe move alias mvo move alias mv move alias x exit # This solves the qmob/qsail collision with quit. alias q quit # Selective production report, which defaults to "a", and not redesignated # sectors. alias pr "prod # ?des=${1:-a}&des=newd" # Selective census, which defaults to "+". alias cd "cen # ?des=${1:-+}" # Selectively find sectors with new designations. alias cdc "cen # ?des#newd&newd=${1:-newd}" # This supports autoconnection. If the AUTOGAME var is not set, # this command is quietly aborted. connect ${AUTOGAME:?} # This is a neat one. Scan back 1 day in the news for news events which do not # match the specified ones. #### tel unocc oplag dplag dfam guer spy ofly fireb alias ncc "news ${1:-1} ?acti#4&acti#12&acti#31&acti#32&acti#34&acti#38&acti#3&acti#9&acti#14" alias nc "ncc ${1:-1} | more" eif/connect000755 002123 000322 00000000000 05745514270 014353 5ustar00childrenpstaff000000 777637 eif/connect/connect.c000644 002123 000322 00000011764 05014777257 016232 0ustar00childrenpstaff000000 763613 /************************************************************* * $Id: connect.c,v 1.6 91/05/17 12:02:35 dhay Exp $ * * connect.c * * Much of this shamelessly cloned from elsewhere. * */ /******************************************************* * Copyright (C) Doug Hay, 1991. * Permission to use and abuse this code, as long * as this copyright notice stays intact and with the * code. No warranty implied. This code supplied as is. *******************************************************/ #include #include #include #include #include #include #include #include #include static int get_hostaddr(); static int get_hostport(); static int hostconnect(); extern int errno; /* This can be fprintf(stderr, ...) */ void eprt(); int empire_connect(host, port, country, rep, kill_it) char *host, *port, *country, *rep; int kill_it; { int sock; char *user, *getenv(); struct sockaddr_in addr; if (!get_hostaddr(host, &addr)) { eprt("Unable to get address of %s\n", host); return(-1); } if (!get_hostport(port, &addr)) { eprt("Unable to convert port %s\n", port); return(-1); } sock = hostconnect(&addr); if (-1 == sock) { eprt("Connection failed.\n"); return(-1); } if (!(user=getenv("USER"))) user = "unknown"; if (!login(sock, user, country, rep, kill_it)) { eprt("Login failed.\n"); close(sock); return(-1); } if (kill_it) { close(sock); return(-1); } return(sock); } /****************************************** * get_hostaddr * * Find the actual net address from the host name. * The host name can be an internet id, or a name. * * Returns 1 if ok, 0 if it failed. */ static int get_hostaddr(host, addr) char *host; struct sockaddr_in *addr; { struct hostent *hptr; if (!host || !*host) return(0); if (isdigit(*host)) { /* Well, it could be an internet address. */ /* Could also be a name starting with a numeric. sick. */ addr->sin_addr.s_addr = inet_addr(host); if (-1 != addr->sin_addr.s_addr) { /* Yeah, worked. */ return(1); } } hptr = gethostbyname(host); if (!hptr) return(0); bcopy(hptr->h_addr, (char *) &addr->sin_addr, sizeof(addr->sin_addr)); return(1); } /****************************************** * get_hostport * * Convert the port string into the proper port id * in the socket address. * If "port" is a numeric string, add it in directly. * Otherwise, look it up in the services. * * Returns 1 if ok, 0 if it fails. */ static int get_hostport(port, addr) char *port; struct sockaddr_in *addr; { struct servent *serv; if (!port || !*port) return(0); if (isdigit(*port)) { addr->sin_port = htons((unsigned short) atol(port)); } else { serv = getservbyname(port, "tcp"); if (!serv) return(0); addr->sin_port = serv->s_port; } return(1); } /****************************************** * hostconnect * * Returns -1 if terrible error occurs. * Returns socket number if succeeds. */ static int hostconnect(addr) struct sockaddr_in *addr; { int sock; sock = socket(AF_INET, SOCK_STREAM, 0); if (-1 == sock) { perror("socket:"); return(-1); } #if 0 /* This just prints some crap about the connection buffering */ { int t, dat, len; t = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *) &dat, &len); if (-1 == t) { eprt("getsockopt failed, %d\n", errno); } else { eprt("getsockopt, sndbuf, %d, %d\n", dat, len); } t = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *) &dat, &len); if (-1 == t) { eprt("getsockopt failed, %d\n", errno); } else { eprt("getsockopt, rcvbuf, %d, %d\n", dat, len); } } #endif addr->sin_family = AF_INET; if (connect(sock, (struct sockaddr *) addr, sizeof(*addr)) == -1) { switch (errno) { case ECONNREFUSED: /* Connection refused */ eprt("Connection refused.\n"); eprt("Game is probably not up.\n"); break; case ETIMEDOUT: /* Connection timed out. */ eprt("Connection timed out.\n"); eprt("Network problems?\n"); break; case ENETUNREACH: /* Network unreachable. */ eprt("Network unreachable.\n"); eprt("Good luck.\n"); break; case EISCONN: /* Already connected??!? */ eprt("Already connected.\n"); return(sock); break; default: perror("hostconnect:"); break; } close(sock); return(-1); } #if 0 /* This just prints some crap about the connection buffering */ { int t, dat, len; /* 6 is tcp's ip protocol number from /etc/protocols.. */ t = getsockopt(sock, 6, TCP_NODELAY, (char *) &dat, &len); if (-1 == t) { eprt("getsockopt tcp failed, %d\n", errno); } else { eprt("getsockopt, nodelay, %d, %d\n", dat, len); } t = getsockopt(sock, 6, TCP_MAXSEG, (char *) &dat, &len); if (-1 == t) { eprt("getsockopt tcp failed, %d\n", errno); } else { eprt("getsockopt, maxseg, %d, %d\n", dat, len); } } #endif return(sock); } eif/connect/expect.c000644 002123 000322 00000004711 05571200511 016043 0ustar00childrenpstaff000000 767044 /**************************************************************** * $Id: expect.c,v 1.4 91/05/17 12:02:45 dhay Exp $ * * expect.c * * Shamelessly thieved from the empire client code written * by Dave Pare. * * Modified as well. * */ #include #include #include #include #include "proto.h" /* This can be fprintf(stderr, ..) */ void eprt(); struct fn { int (*func)(); char *name; int value; }; struct fn fnlist[] = { { NULL, "user", USER,}, { NULL, "coun", COUN,}, { NULL, "quit", QUIT,}, { NULL, "pass", PASS,}, { NULL, "play", PLAY,}, { NULL, "list", LIST,}, { NULL, "cmd", CMD,}, { NULL, "ctld", CTLD,}, { NULL, "wat", WAT,}, { NULL, "kill", KILL,}, { NULL, "", 0,}, }; int expect(s, match, buf) int s; int match; char *buf; { extern char *index(); int size; char *p; int n; int code; int newline; char *ptr; int cc; size = 1024; /* This was 10. A little too slow. */ (void) alarm(60); ptr = buf; n = recv(s, ptr, size, MSG_PEEK); if (n <= 0) { eprt("Expecting code %d\n", match); perror("recv"); return 0; } size -= n; buf[n] = '\0'; if ((p = index(ptr, '\n')) == 0) { do { cc = read(s, ptr, n); if (cc < 0) { perror("expect: read"); return 0; } if (cc != n) { eprt("expect: short read (%d not %d)\n", cc, n); return 0; } ptr += n; if ((n = recv(s, ptr, size, MSG_PEEK)) <= 0) { eprt("1Expecting %d, got %s\n", match, buf); return 0; } size -= n; ptr[n] = '\0'; } while ((p = index(ptr, '\n')) == 0); newline = 1 + p - buf; *p = 0; } else newline = 1 + p - ptr; cc = read(s, buf, newline); if (cc < 0) { perror("expect: read #2"); return 0; } if (cc != newline) { eprt("expect: short read #2 (%d not %d)\n", cc, newline); return 0; } buf[newline] = '\0'; (void) alarm(0); if (!isxdigit(*buf)) { eprt("2Expecting %d, got %s\n", match, buf); return 0; } if (isdigit(*buf)) code = *buf - '0'; else { if (isupper(*buf)) *buf = tolower(*buf); code = 10 + *buf - 'a'; } if (code == match) return 1; return 0; } int sendcmd(s, cmd, arg) int s; int cmd; char *arg; { extern struct fn fnlist[]; char buf[80]; int cc; int len; (void) sprintf(buf, "%s %s\n", fnlist[cmd].name, arg != 0 ? arg : ""); len = strlen(buf); cc = write(s, buf, len); if (cc < 0) { perror("sendcmd: write"); } if (cc != len) { eprt("sendcmd: short write (%d not %d)\n", cc, len); } } eif/connect/login.c000644 002123 000322 00000003241 05014777260 015674 0ustar00childrenpstaff000000 777070 /************************************************************* * $Id: login.c,v 1.3 91/05/17 12:02:47 dhay Exp $ * * login.c * * Shamelessly stolen from the original empire client. * With some minor modifications. */ /* * * Log in to empire host * * Dave Pare, 1989 */ #include "proto.h" #include #include #include #ifdef hpux #include #else #include #endif /* This can be fprintf(stderr, ...) */ void eprt(); /* This can be printf() */ void prt(); int login(s, uname, cname, cpass, kill_it) int s; char *uname; char *cname; char *cpass; int kill_it; { extern char *getpass(), *index(); char buf[1024]; char *ptr; char *p; if (!uname || !*uname || !cname || !*cname || !cpass || !*cpass) return(0); if (!expect(s, C_INIT, buf)) return 0; (void) sendcmd(s, USER, uname); if (!expect(s, C_CMDOK, buf)) return 0; (void) sendcmd(s, COUN, cname); if (!expect(s, C_CMDOK, buf)) { eprt("empire: no such country\n"); return 0; } prt("\n"); (void) sendcmd(s, PASS, cpass); if (!expect(s, C_CMDOK, buf)) { eprt("Bad password\n"); return 0; } if (kill_it) { (void) sendcmd(s, KILL, (char *)0); prt("\n\t-=O=-\n"); (void) expect(s, C_INIT, buf); eprt("%s\n", buf); return(1); } (void) sendcmd(s, PLAY, (char *)0); prt("\n\t-=O=-\n"); if (!expect(s, C_INIT, buf)) { eprt("%s\n", buf); return 0; } for (ptr = buf; !isspace(*ptr); ptr++) ; ptr++; p = index(ptr, '\n'); if (p != 0) *p = 0; if (atoi(ptr) != CLIENTPROTO) { eprt("Empire client out of date; get new version!\n"); eprt(" this version: %d, remote version: %d\n", CLIENTPROTO, atoi(ptr)); } return 1; } eif/connect/sock.c000644 002123 000322 00000014050 06013045051 015475 0ustar00childrenpstaff000000 760250 /******************************************************* * $Id: sock.c,v 1.6 91/05/17 12:02:48 dhay Exp $ * * sock.c * * Send and receive information to/from emp_player. * * Doug Hay. * * Heavily modified from source by: * Jon Sari, 1990 */ #include #include #include #include #include #include "proto.h" void writesock(); static char *grab_line(); char *index(); /* If this is set, we had an interrupt */ extern int Interrupt; /* This set if a pipe interrupt */ extern int Pipe_Interrupt; /* This can be fprintf(stderr, ...) */ void eprt(); /* This can be printf() */ void prt(); /* This can be fputs() */ void myfputs(); /* Parsed from prompts coming back. */ extern int game_time, game_btus; static char sockbuf[2048]; /***************************************** * readsock * * * Returns: * -1 - when lost the connection. * 0 - not dreadable, data timeout? * 1 - a main prompt is sent. * 2 - when a flush is sent. */ int readsock(sock, fp, timeout, prompt, prsize) int sock; /* Descriptor to read from */ FILE *fp; /* Pointer to write to */ int timeout; /* Max time in seconds to wait for read */ char *prompt; int prsize; { int sentabort=0; /* Whether we sent an abort or not. */ static char *ptr=sockbuf; /* Current place in the display buffer */ int the_ret=0; /* Possible return value */ char *cp; int cc; int count; int expected; char display[512]; /* If there was an interrupt, let us try to abort. */ if (Interrupt) { eprt("Sending abort\n"); writesock(sock, "\naborted"); Interrupt = 0; sentabort = 1; } ptr = 0; expected = 0; /* While there is data to read, within the timeout we are * to wait, read data. */ while (dreadable(sock, timeout)) { if (ptr && *ptr) { /* We have an incomplete line left in the buffer. */ count = strlen(ptr); strcpy(sockbuf, ptr); } else count = 0; ptr = sockbuf + count; /* Get more data from emp_player */ if ((cc = read(sock, ptr, sizeof(sockbuf)-count)) < 0) { perror("socket read"); return(-1); } if (cc == 0) { eprt("Server EOF\n"); return(-1); } /* Make sure it is ended with a null */ sockbuf[cc+count] = '\0'; ptr = sockbuf; /* While there are complete lines left, look at them */ while (index(ptr, '\n')) { /* Parse the line. */ ptr = grab_line(ptr, &expected, display); if (-1 != the_ret) the_ret = 0; switch (expected) { case C_PROMPT: (void) sscanf(display, "%d %d", &game_time, &game_btus); if (-1 != the_ret) the_ret = 1; sentabort = 0; break; case C_DATA: /* XXXX We need to check for inverse characters. */ if (fp && !Pipe_Interrupt) myfputs(display, fp); break; case C_EXIT: /* Well, says he wants to quit. */ /* Game over, man. */ if (fp) fprintf(fp, "%s\n", display); the_ret = -1; break; case C_FLUSH: /* A prompt, but not a command-line one. */ if ((cp=index(display, '\n'))) *cp = '\0'; if (prompt) { strncpy(prompt, display, prsize-1); } else printf("%s", display); if ((-1 != the_ret) && !sentabort) the_ret = 2; break; case C_FLASH: printf("\n%s", display); break; case C_INFORM: printf("\nInform mode is not supported by eif. Please type \"toggle inform\"\n%s\n", display); break; case C_CMDERR: case C_BADCMD: eprt("Error; %s\n", display); break; case C_PIPE: /* Should not occur */ case C_REDIR: /* Should not occur */ eprt("Damn, let a redirection command through.\n"); break; case C_EXECUTE: /* Should not occur */ eprt("Damn, let an exec command through.\n"); break; case C_CMDOK: case C_INIT: case C_NOECHO: case C_ABORT: eprt("Unexpected protocol, %d\n", expected); break; default: eprt("Unknown protocol code, %d\n", expected); break; } } if (!*ptr) { ptr = sockbuf; *ptr = '\0'; } if (Interrupt) { eprt("Sending abort\n"); Interrupt = 0; writesock(sock, "\naborted"); sentabort = 1; } if (fp && !Pipe_Interrupt) fflush(fp); if (the_ret) { /* If we had a return set (a prompt of some form) * and there is no more data to read, * then return the prompt type. */ if (!dreadable(sock, 0) && !*ptr) return(the_ret); } } return(0); } /* * A neat-o routine to tell whether a descriptor has any data available. * * Jon "Rob McKenna was a rain god . . . " Sari, 1990 */ /* Returns: * 1 - if 's' has data ready to be read. * 0 - if 's' has no data ready to be read. * -1 - if a problem occured. Maybe an Interrupt. * * 'wait' is the time, in seconds, to wait for data. * If 'wait' is zero, then this is a check to see if data is available. */ int dreadable(s, wait) int s, wait; { struct fd_set read_fd; struct timeval timeout; int rval; extern int errno; timeout.tv_sec = wait; timeout.tv_usec = 0; FD_ZERO(&read_fd); FD_SET(s, &read_fd); rval = select(s+1, &read_fd, (fd_set *)0, (fd_set *)0, &timeout); if (rval<0 && errno==EINTR) Interrupt++; return rval; } /* * A routine to write a string to a socket. * Actually, pretty dull. * * Jon "Fwuh!" Sari, 1990 */ void writesock(s, cmd) int s; char *cmd; { register int i = 0; while (*cmd) sockbuf[i++] = *cmd++; sockbuf[i++] = '\n'; sockbuf[i] = 0; if (write(s, sockbuf, i) < i) perror("socket write"); } /* * A routine to replace sscanf("%x%*c%[^\n]", &no, line) which strips * off signed character data. (It's faster, anyhow.) * * Jon "Heh heh heh" Sari, 1990 */ static char * grab_line(p, no, line) char *p; int *no; char *line; { *no = (*p <= '9') ? *p - '0' : ((*p < 'G') ? *p -'A'+10 : *p -'a'+10); p += 2; while (*p && *p != '\n') *line++ = *p++; if ('\n' == *p) { *line++ = *p++; } else *line++ = '\n'; *line = '\0'; return(p); } eif/connect/proto.h000644 002123 000322 00000001605 06013045064 015760 0ustar00childrenpstaff000000 1000007 /* * proto.h * * The master copy of this is in the standard include directory. * A copy is placed in the client directory to allow client * to be compiled independently of the rest of the game. * * Dave Pare, 1986 * $Revision: 2.2 $ $Date: 1995/07/07 17:15:44 $ */ #define CLIENTPROTO 2 /* if new things are added, bump this */ #define USER 0 #define COUN 1 #define QUIT 2 #define PASS 3 #define PLAY 4 #define LIST 5 #define CMD 6 #define CTLD 7 #define WAT 8 #define KILL 9 #define GKILL 10 /* kill even if process stuck --ts */ #define C_CMDOK 0x0 #define C_DATA 0x1 #define C_INIT 0x2 #define C_EXIT 0x3 #define C_FLUSH 0x4 #define C_NOECHO 0x5 #define C_PROMPT 0x6 #define C_ABORT 0x7 #define C_REDIR 0x8 #define C_PIPE 0x9 #define C_CMDERR 0xA #define C_BADCMD 0xB #define C_EXECUTE 0xC #define C_FLASH 0xD #define C_INFORM 0xE #define C_LAST 0xE ROTO) { eprt("Empire client out of date; get new version!\n"); eprt(" this version: %d, remote version: %d\n", CLIENTPROTO, atoi(ptr)); } return 1; } eif/connect/sock.c000644 002123 000322 00000014050 06013045051 015475 0ustar00childrenpstaff000000 760250 /******************************************************* * $Id: sock.c,v 1.6 91/05/17 12:02:48 dhay Exp $ * * sock.c * * Send and receive information to/from emp_player. * * Doug Hay. * * Heavily modified from source by: * Jon Sari, 1990 */ #include #include #include #include #include #include "proto.h" void writesock(); static char *grab_line(); char *index(); /* If this is set, we had an interrupt */ extern int Interrupt; /* This set if a pipe interrupt */ extern int Pipe_Interrupt; /* This can be fprintf(stderr, ...) */ void eprt(); /* This can be printf() */ void prt(); /* This can be fputs() */ void myfputs(); /* Parsed from prompts coming back. */ extern int game_time, game_btus; static char sockbuf[2048]; /***************************************** * readsock * * * Returns: * -1 - when lost the connection. * 0 - not dreadable, data timeout? * 1 - a main prompt is sent. * 2 - when a flush is sent. */ int readsock(sock, fp, timeout, prompt, prsize) int sock; /* Descriptor to read from */ FILE *fp; /* Pointer to write to */ int timeout; /* Max time in seconds to wait for read */ char *prompt; int prsize; { int sentabort=0; /* Whether we sent an abort or not. */ static char *ptr=sockbuf; /* Current place in the display buffer */ int the_ret=0; /* Possible return value */ char *cp; int cc; int count; int expected; char display[512]; /* If there was an interrupt, let us try to abort. */ if (Interrupt) { eprt("Sending abort\n"); writesock(sock, "\naborted"); Interrupt = 0; sentabort = 1; } ptr = 0; expected = 0; /* While there is data to read, within the timeout we are * to wait, read data. */ while (dreadable(sock, timeout)) { if (ptr && *ptr) { /* We have an incomplete line left in the buffer. */ count = strlen(ptr); strcpy(sockbuf, ptr); } else count = 0; ptr = sockbuf + count; /* Get more data from emp_player */ if ((cc = read(sock, ptr, sizeof(sockbuf)-count)) < 0) { perror("socket read"); return(-1); } if (cc == 0) { eprt("Server EOF\n"); return(-1); } /* Make sure it is ended with a null */ sockbuf[cc+count] = '\0'; ptr = sockbuf; /* While there are complete lines left, look at them */ while (index(ptr, '\n')) { /* Parse the line. */ ptr = grab_line(ptr, &expected, display); if (-1 != the_ret) the_ret = 0; switch (expected) { case C_PRO