/*
* Extended (M-X) commands, rebinding, and
* startup file processing.
*/
#include "def.h"
#include "kbd.h"
#ifndef NO_MACRO
#include "macro.h"
#endif
#ifdef FKEYS
#include "key.h"
#ifndef NO_STARTUP
#ifndef BINDKEY
#define BINDKEY /* bindkey is used by FKEYS startup code */
#endif
#endif
#endif
extern char *strncpy();
extern int rescan();
/* insert a string, mainly for use from macros (created by selfinsert) */
/*ARGSUSED*/
insert(f, n)
int f, n;
{
register char *cp;
char buf[128];
#ifndef NO_MACRO
register int count;
int c;
if(inmacro) {
while(--n >= 0) {
for(count = 0; count < maclcur->l_used; count++) {
if((((c=maclcur->l_text[count]) == '\n') ? lnewline()
: linsert(1, c)) != TRUE) return FALSE;
}
}
maclcur = maclcur->l_fp;
return TRUE;
}
if(n==1) thisflag |= CFINS; /* CFINS means selfinsert can tack on end */
#endif
if(eread("Insert: ", buf, sizeof(buf), EFNEW) == FALSE) return FALSE;
while(--n >= 0) {
cp = buf;
while(*cp) {
if(((*cp == '\n') ? lnewline() : linsert(1, *cp)) != TRUE)
return FALSE;
cp++;
}
}
return TRUE;
}
/*
* Bind a key to a function. Cases range from the trivial (replacing an
* existing binding) to the extremly complex (creating a new prefix in a
* map_element that already has one, so the map_element must be split,
* but the keymap doesn't have enough room for another map_element, so
* the keymap is reallocated). No attempt is made to reclaim space no
* longer used, if this is a problem flags must be added to indicate
* malloced verses static storage in both keymaps and map_elements.
* Structure assignments would come in real handy, but K&R based compilers
* don't have them. Care is taken so running out of memory will leave
* the keymap in a usable state.
*/
static int remap(curmap, c, funct, pref_map)
register KEYMAP *curmap;/* pointer to the map being changed */
int c; /* character being changed */
PF funct; /* function being changed to */
KEYMAP *pref_map; /* if funct==prefix, map to bind to or NULL for new */
/* extern MAP_ELEMENT *ele; must be set before calling */
{
register int i;
int n1, n2, nold;
KEYMAP *mp;
PF *pfp;
MAP_ELEMENT *mep;
static KEYMAP *realocmap();
if(ele >= &curmap->map_element[curmap->map_num] || c < ele->k_base) {
if(ele > &curmap->map_element[0] && (funct!=prefix ||
(ele-1)->k_prefmap==NULL)) {
n1 = c - (ele-1)->k_num;
} else n1 = HUGE;
if(ele < &curmap->map_element[curmap->map_num] && (funct!=prefix ||
ele->k_prefmap==NULL)) {
n2 = ele->k_base - c;
} else n2 = HUGE;
if(n1 <= MAPELEDEF && n1 <= n2) {
ele--;
if((pfp = (PF *)malloc((unsigned)(c - ele->k_base+1)
* sizeof(PF))) == NULL) {
ewprintf("Out of memory");
return FALSE;
}
nold = ele->k_num - ele->k_base + 1;
for(i=0; i < nold; i++)
pfp[i] = ele->k_funcp[i];
while(--n1) pfp[i++] = curmap->map_default;
pfp[i] = funct;
ele->k_num = c;
ele->k_funcp = pfp;
} else if(n2 <= MAPELEDEF) {
if((pfp = (PF *)malloc((unsigned)(ele->k_num - c + 1)
* sizeof(PF))) == NULL) {
ewprintf("Out of memory");
return FALSE;
}
nold = ele->k_num - ele->k_base + 1;
for(i=0; i < nold; i++)
pfp[i+n2] = ele->k_funcp[i];
while(--n2) pfp[n2] = curmap->map_default;
pfp[0] = funct;
ele->k_base = c;
ele->k_funcp = pfp;
} else {
if(curmap->map_num >= curmap->map_max &&
(curmap = realocmap(curmap)) == NULL) return FALSE;
if((pfp = (PF *)malloc(sizeof(PF))) == NULL) {
ewprintf("Out of memory");
return FALSE;
}
pfp[0] = funct;
for(mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) {
mep->k_base = (mep-1)->k_base;
mep->k_num = (mep-1)->k_num;
mep->k_funcp = (mep-1)->k_funcp;
mep->k_prefmap = (mep-1)->k_prefmap;
}
ele->k_base = c;
ele->k_num = c;
ele->k_funcp = pfp;
ele->k_prefmap = NULL;
curmap->map_num++;
}
if(funct == prefix) {
if(pref_map != NULL) {
ele->k_prefmap = pref_map;
} else {
if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) +
(MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) {
ewprintf("Out of memory");
ele->k_funcp[c - ele->k_base] = curmap->map_default;
return FALSE;
}
mp->map_num = 0;
mp->map_max = MAPINIT;
mp->map_default = rescan;
ele->k_prefmap = mp;
}
}
} else {
n1 = c - ele->k_base;
if(ele->k_funcp[n1] == funct && (funct!=prefix || pref_map==NULL ||
pref_map==ele->k_prefmap))
return TRUE; /* no change */
if(funct!=prefix || ele->k_prefmap==NULL) {
if(ele->k_funcp[n1] == prefix)
ele->k_prefmap = (KEYMAP *)NULL;
ele->k_funcp[n1] = funct; /* easy case */
if(funct==prefix) {
if(pref_map!=NULL)
ele->k_prefmap = pref_map;
else {
if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) +
(MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) {
ewprintf("Out of memory");
ele->k_funcp[c - ele->k_base] = curmap->map_default;
return FALSE;
}
mp->map_num = 0;
mp->map_max = MAPINIT;
mp->map_default = rescan;
ele->k_prefmap = mp;
}
}
} else {
/* this case is the splits */
/* determine which side of the break c goes on */
/* 0 = after break; 1 = before break */
n2 = 1;
for(i=0; n2 && i < n1; i++)
n2 &= ele->k_funcp[i] != prefix;
if(curmap->map_num >= curmap->map_max &&
(curmap = realocmap(curmap)) == NULL) return FALSE;
if((pfp = (PF *)malloc((unsigned)(ele->k_num - c + !n2)
* sizeof(PF))) == NULL) {
ewprintf("Out of memory");
return FALSE;
}
ele->k_funcp[n1] = prefix;
for(i=n1+n2; i <= ele->k_num - ele->k_base; i++)
pfp[i-n1-n2] = ele->k_funcp[i];
for(mep = &curmap->map_element[curmap->map_num]; mep > ele; mep--) {
mep->k_base = (mep-1)->k_base;
mep->k_num = (mep-1)->k_num;
mep->k_funcp = (mep-1)->k_funcp;
mep->k_prefmap = (mep-1)->k_prefmap;
}
ele->k_num = c - !n2;
(ele+1)->k_base = c + n2;
(ele+1)->k_funcp = pfp;
ele += !n2;
ele->k_prefmap = NULL;
curmap->map_num++;
if(pref_map == NULL) {
if((mp = (KEYMAP *)malloc(sizeof(KEYMAP) +
(MAPINIT-1)*sizeof(MAP_ELEMENT))) == NULL) {
ewprintf("Out of memory");
ele->k_funcp[c - ele->k_base] = curmap->map_default;
return FALSE;
}
mp->map_num = 0;
mp->map_max = MAPINIT;
mp->map_default = rescan;
ele->k_prefmap = mp;
} else ele->k_prefmap = pref_map;
}
}
return TRUE;
}
/* reallocate a keymap, used above */
static KEYMAP *realocmap(curmap)
register KEYMAP *curmap;
{
register KEYMAP *mp;
register int i;
static VOID fixmap();
extern int nmaps;
if((mp = (KEYMAP *)malloc((unsigned)(sizeof(KEYMAP)+
(curmap->map_max+(MAPGROW-1))*sizeof(MAP_ELEMENT)))) == NULL) {
ewprintf("Out of memory");
return NULL;
}
mp->map_num = curmap->map_num;
mp->map_max = curmap->map_max + MAPGROW;
mp->map_default = curmap->map_default;
for(i=curmap->map_num; i--; ) {
mp->map_element[i].k_base = curmap->map_element[i].k_base;
mp->map_element[i].k_num = curmap->map_element[i].k_num;
mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp;
mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap;
}
for(i=nmaps; i--; ) {
if(map_table[i].p_map == curmap) map_table[i].p_map = mp;
else fixmap(curmap, mp, map_table[i].p_map);
}
ele = &mp->map_element[ele - &curmap->map_element[0]];
return mp;
}
/* fix references to a reallocated keymap (recursive) */
static VOID fixmap(curmap, mp, mt)
register KEYMAP *mt;
register KEYMAP *curmap;
KEYMAP *mp;
{
register int i;
for(i = mt->map_num; i--; ) {
if(mt->map_element[i].k_prefmap != NULL) {
if(mt->map_element[i].k_prefmap == curmap)
mt->map_element[i].k_prefmap = mp;
else fixmap(curmap, mp, mt->map_element[i].k_prefmap);
}
}
}
/*
* do the input for local-set-key, global-set-key and define-key
* then call remap to do the work.
*/
static int dobind(curmap, p, unbind)
register KEYMAP *curmap;
char *p;
int unbind;
{
PF funct;
char prompt[80];
char *pep;
int c;
int s;
KEYMAP *pref_map = NULL;
#ifndef NO_MACRO
if(macrodef) {
/* keystrokes arn't collected. Not hard, but pretty useless */
/* would not work for function keys in any case */
ewprintf("Can't rebind key in macro");
return FALSE;
}
#ifndef NO_STARTUP
if(inmacro) {
for(s=0; s < maclcur->l_used - 1; s++) {
if(doscan(curmap, c=CHARMASK(maclcur->l_text[s])) != prefix) {
if(remap(curmap, c, prefix, (KEYMAP *)NULL) != TRUE) {
return FALSE;
}
}
curmap = ele->k_prefmap;
}
(VOID) doscan(curmap, c=maclcur->l_text[s]);
maclcur = maclcur->l_fp;
} else {
#endif
#endif
(VOID) strcpy(prompt, p);
pep = prompt + strlen(prompt);
for(;;) {
ewprintf("%s", prompt);
pep[-1] = ' ';
pep = keyname(pep, c = getkey(FALSE));
if(doscan(curmap,c) != prefix) break;
*pep++ = '-';
*pep = '\0';
curmap = ele->k_prefmap;
}
#ifndef NO_STARTUP
}
#endif
if(unbind) funct = rescan;
else {
if ((s=eread("%s to command: ", prompt, 80, EFFUNC|EFNEW, prompt))
!= TRUE) return s;
if (((funct = name_function(prompt)) == prefix) ?
(pref_map = name_map(prompt)) == NULL : funct==NULL) {
ewprintf("[No match]");
return FALSE;
}
}
return remap(curmap, c, funct, pref_map);
}
/*
* bindkey: bind key sequence to a function in
* the specified map. Used by excline so it can bind function keys.
* To close to release to change calling sequence, should just pass
* KEYMAP *curmap rather than KEYMAP **mapp.
*/
#ifdef BINDKEY
bindkey(mapp, fname, keys, kcount)
KEYMAP **mapp;
char *fname;
KCHAR *keys;
int kcount;
{
KEYMAP *curmap = *mapp;
PF funct;
int c;
KEYMAP *pref_map = NULL;
if(fname == NULL) funct = rescan;
else if (((funct = name_function(fname)) == prefix) ?
(pref_map = name_map(fname)) == NULL : funct==NULL) {
ewprintf("[No match: %s]", fname);
return FALSE;
}
while(--kcount) {
if(doscan(curmap, c = *keys++) != prefix) {
if(remap(curmap, c, prefix, (KEYMAP *)NULL) != TRUE)
return FALSE;
}
curmap = ele->k_prefmap;
}
(VOID) doscan(curmap, c = *keys);
return remap(curmap, c, funct, pref_map);
}
#endif
/*
* This function modifies the fundamental keyboard map.
*/
/*ARGSUSED*/
bindtokey(f, n)
{
return dobind(map_table[0].p_map, "Global set key: ", FALSE);
}
/*
* This function modifies the current mode's keyboard map.
*/
/*ARGSUSED*/
localbind(f, n)
{
return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local set key: ",
FALSE);
}
/*
* This function redefines a key in any keymap.
*/
/*ARGSUSED*/
define_key(f, n)
{
static char buf[48] = "Define key map: ";
MAPS *mp;
char *strncat();
buf[16] = '\0';
if(eread(buf, &buf[16], 48 - 16, EFNEW) != TRUE) return FALSE;
if((mp = name_mode(&buf[16])) == NULL) {
ewprintf("Unknown map %s", &buf[16]);
return FALSE;
}
(VOID) strncat(&buf[16], " key: ", 48-16-1);
return dobind(mp->p_map, buf, FALSE);
}
unbindtokey(f, n)
int f, n;
{
return dobind(map_table[0].p_map, "Global unset key: ", TRUE);
}
localunbind(f, n)
int f, n;
{
return dobind(curbp->b_modes[curbp->b_nmodes]->p_map, "Local unset key: ",
TRUE);
}
/*
* Extended command. Call the message line
* routine to read in the command name and apply autocompletion
* to it. When it comes back, look the name up in the symbol table
* and run the command if it is found.
* Print an error if there is anything wrong.
*/
extend(f, n)
{
PF funct;
int s;
char xname[NXNAME];
if(!(f & FFARG)) s = eread("M-x ", xname, NXNAME, EFNEW|EFFUNC);
else s = eread("%d M-x ", xname, NXNAME, EFNEW|EFFUNC, n);
if(s != TRUE) return s;
if((funct = name_function(xname)) != NULL) {
#ifndef NO_MACRO
if(macrodef) {
LINE *lp = maclcur;
macro[macrocount-1].m_funct = funct;
maclcur = lp->l_bp;
maclcur->l_fp = lp->l_fp;
free((char *)lp);
}
#endif
return (*funct)(f, n);
}
ewprintf("[No match]");
return FALSE;
}
#ifndef NO_STARTUP
/*
* Define the commands needed to do startup-file processing.
* This code is mostly a kludge just so we can get startup-file processing.
*
* If you're serious about having this code, you should rewrite it.
* To wit:
* It has lots of funny things in it to make the startup-file look
* like a GNU startup file; mostly dealing with parens and semicolons.
* This should all vanish.
*
* We define eval-expression because it's easy. It can make
* *-set-key or define-key set an arbitrary key sequence, so it isn't
* useless.
*/
/*
* evalexpr - get one line from the user, and run it.
*/
/*ARGSUSED*/
evalexpr(f, n)
{
int s;
char exbuf[128];
if ((s = ereply("Eval: ", exbuf, 128)) != TRUE)
return s;
return excline(exbuf);
}
/*
* evalbuffer - evaluate the current buffer as line commands. Useful
* for testing startup files.
*/
/*ARGSUSED*/
evalbuffer(f, n)
{
register LINE *lp;
register BUFFER *bp = curbp;
register int s;
static char excbuf[128];
for (lp = lforw(bp->b_linep); lp != bp->b_linep; lp = lforw(lp)) {
if (llength(lp) >= 128) return FALSE;
(VOID) strncpy(excbuf, ltext(lp), llength(lp));
excbuf[llength(lp)] = '\0'; /* make sure it's terminated */
if ((s = excline(excbuf)) != TRUE) return s;
}
return TRUE;
}
/*
* evalfile - go get a file and evaluate it as line commands. You can
* go get your own startup file if need be.
*/
/*ARGSUSED*/
evalfile(f, n)
{
register int s;
char fname[NFILEN];
if ((s = ereply("Load file: ", fname, NFILEN)) != TRUE)
return s;
return load(fname);
}
/*
* load - go load the file name we got passed.
*/
load(fname) char *fname; {
int s = TRUE;
int nbytes;
char excbuf[128];
if ((fname = adjustname(fname)) == NULL)
return FALSE; /* just to be careful */
if (ffropen(fname, (BUFFER *) NULL) != FIOSUC) return FALSE;
while ((s = ffgetline(excbuf, sizeof(excbuf)-1, &nbytes)) == FIOSUC) {
excbuf[nbytes] = '\0';
if (excline(excbuf) != TRUE) {
s = FIOERR;
ewprintf("Error loading file %s", fname);
break;
}
}
(VOID) ffclose((BUFFER *) NULL);
excbuf[nbytes] = '\0';
if(s!=FIOEOF || (nbytes && excline(excbuf)!=TRUE))
return FALSE;
return TRUE;
}
/*
* excline - run a line from a load file or eval-expression.
* if FKEYS is defined, duplicate functionallity of dobind so function
* key values don't have to fit in type char.
*/
excline(line)
register char *line;
{
register char *funcp, *argp = NULL;
register int c;
int status;
int f, n;
LINE *lp, *np;
PF fp;
#ifdef FKEYS
int bind;
KEYMAP *curmap;
MAPS *mp;
#define BINDARG 0 /* this arg is key to bind (local/global set key) */
#define BINDNO 1 /* not binding or non-quoted BINDARG */
#define BINDNEXT 2 /* next arg " (define-key) */
#define BINDDO 3 /* already found key to bind */
#define BINDEXT 1 /* space for trailing \0 */
#else
#define BINDEXT 0
#endif
PF name_function();
LINE *lalloc();
static char *skipwhite(), *parsetoken();
if(macrodef || inmacro) {
ewprintf("Not now!");
return FALSE;
}
f = 0;
n = 1;
funcp = skipwhite(line);
if (*funcp == '\0') return TRUE; /* No error on blank lines */
line = parsetoken(funcp);
if (*line != '\0') {
*line++ = '\0';
line = skipwhite(line);
if ((*line >= '0' && *line <= '9') || *line == '-') {
argp = line;
line = parsetoken(line);
}
}
if (argp != NULL) {
f = FFARG;
n = atoi(argp);
}
if((fp = name_function(funcp)) == NULL) {
ewprintf("Unknown function: %s", funcp);
return FALSE;
}
#ifdef FKEYS
if(fp == bindtokey || fp == unbindtokey) {
bind = BINDARG;
curmap = map_table[0].p_map;
} else if(fp == localbind || fp == localunbind) {
bind = BINDARG;
curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
} else if(fp == define_key) bind = BINDNEXT;
else bind = BINDNO;
#endif
/* Pack away all the args now... */
if((np = lalloc(0))==FALSE) return FALSE;
np->l_fp = np->l_bp = maclcur = np;
while (*line != '\0') {
argp = skipwhite(line);
if (*argp == '\0') break;
line = parsetoken(argp);
if (*argp != '"') {
if (*argp == '\'') ++argp;
if((lp = lalloc((int)(line-argp)+BINDEXT))==NULL) {
status = FALSE;
goto cleanup;
}
bcopy(argp, ltext(lp), (int)(line-argp));
#ifdef FKEYS
lp->l_used--; /* don't count BINDEXT! */
if(bind == BINDARG) bind = BINDNO;
#endif
} else { /* Quoted strings special */
++argp;
#ifdef FKEYS
if(bind != BINDARG) {
#endif
if((lp = lalloc((int)(line-argp)+BINDEXT))==NULL) {
status = FALSE;
goto cleanup;
}
lp->l_used = 0;
#ifdef FKEYS
} else {
key.k_count = 0;
}
#endif
while (*argp != '"' && *argp != '\0') {
if (*argp != '\\') c = *argp++;
else {
switch(*++argp) {
case 't': case 'T':
c = CCHR('I');
break;
case 'n': case 'N':
c = CCHR('J');
break;
case 'r': case 'R':
c = CCHR('M');
break;
case 'e': case 'E':
c = CCHR('[');
break;
case '^':
/* split into two statements due to bug in OSK cpp */
c = CHARMASK(*++argp);
c = ISLOWER(c) ?
CCHR(TOUPPER(c)) : CCHR(c);
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c = *argp - '0';
if(argp[1] <= '7' && argp[1] >= '0') {
c <<= 3;
c += *++argp - '0';
if(argp[1] <= '7' && argp[1] >= '0') {
c <<= 3;
c += *++argp - '0';
}
}
break;
#ifdef FKEYS
case 'f': case 'F':
c = *++argp - '0';
if(ISDIGIT(argp[1])) {
c *= 10;
c += *++argp - '0';
}
c += KFIRST;
break;
#endif
default:
c = CHARMASK(*argp);
break;
}
argp++;
}
#ifdef FKEYS
if(bind == BINDARG)
key.k_chars[key.k_count++] = c;
else
#endif
lp->l_text[lp->l_used++] = c;
}
if(*line) line++;
}
#ifdef FKEYS
switch(bind) {
case BINDARG:
bind = BINDDO;
break;
case BINDNEXT:
lp->l_text[lp->l_used] = '\0';
if((mp = name_mode(lp->l_text)) == NULL) {
ewprintf("No such mode: %s", lp->l_text);
status = FALSE;
free((char *)lp);
goto cleanup;
}
curmap = mp->p_map;
free((char *)lp);
bind = BINDARG;
break;
default:
#endif
lp->l_fp = np->l_fp;
lp->l_bp = np;
np->l_fp = lp;
np = lp;
#ifdef FKEYS
}
#endif
}
#ifdef FKEYS
switch(bind) {
default:
ewprintf("Bad args to set key");
status = FALSE;
break;
case BINDDO:
if(fp != unbindtokey && fp != localunbind) {
lp->l_text[lp->l_used] = '\0';
status = bindkey(&curmap, lp->l_text, key.k_chars, key.k_count);
} else status = bindkey(&curmap, (char *)NULL, key.k_chars, key.k_count);
break;
case BINDNO:
#endif
inmacro = TRUE;
maclcur = maclcur->l_fp;
status = (*fp)(f, n);
inmacro = FALSE;
#ifdef FKEYS
}
#endif
cleanup:
lp = maclcur->l_fp;
while(lp!=maclcur) {
np = lp->l_fp;
free((char *)lp);
lp = np;
}
free((char *)lp);
return status;
}
/*
* a pair of utility functions for the above
*/
static char *
skipwhite(s)
register char *s;
{
while(*s == ' ' || *s == '\t' || *s == ')' || *s == '(') s++;
if (*s == ';') *s = '\0' ;
return s;
}
static char *
parsetoken(s)
register char *s;
{
if (*s != '"') {
while(*s && *s!=' ' && *s!='\t' && *s!=')' && *s!='(') s++;
if(*s==';') *s='\0';
} else
do { /* Strings get special treatment */
/* Beware: You can \ out the end of the string! */
if (*s == '\\') ++s;
} while (*++s != '"' && *s != '\0');
return s;
}
#endif
![[BACK]](/icons/back.gif){kind=icon}
Return to extend.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mg