853 lines
16 KiB
C
853 lines
16 KiB
C
/* input.c */
|
|
|
|
/* Author:
|
|
* Steve Kirkendall
|
|
* 14407 SW Teal Blvd. #C
|
|
* Beaverton, OR 97005
|
|
* kirkenda@cs.pdx.edu
|
|
*/
|
|
|
|
|
|
/* This file contains the input() function, which implements vi's INPUT mode.
|
|
* It also contains the code that supports digraphs.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "ctype.h"
|
|
#include "vi.h"
|
|
|
|
|
|
#ifndef NO_DIGRAPH
|
|
static struct _DIG
|
|
{
|
|
struct _DIG *next;
|
|
char key1;
|
|
char key2;
|
|
char dig;
|
|
char save;
|
|
} *digs;
|
|
|
|
char digraph(key1, key2)
|
|
char key1; /* the underlying character */
|
|
char key2; /* the second character */
|
|
{
|
|
int newkey;
|
|
REG struct _DIG *dp;
|
|
|
|
/* if digraphs are disabled, then just return the new char */
|
|
if (!*o_digraph)
|
|
{
|
|
return key2;
|
|
}
|
|
|
|
/* remember the new key, so we can return it if this isn't a digraph */
|
|
newkey = key2;
|
|
|
|
/* sort key1 and key2, so that their original order won't matter */
|
|
if (key1 > key2)
|
|
{
|
|
key2 = key1;
|
|
key1 = newkey;
|
|
}
|
|
|
|
/* scan through the digraph chart */
|
|
for (dp = digs;
|
|
dp && (dp->key1 != key1 || dp->key2 != key2);
|
|
dp = dp->next)
|
|
{
|
|
}
|
|
|
|
/* if this combination isn't in there, just use the new key */
|
|
if (!dp)
|
|
{
|
|
return newkey;
|
|
}
|
|
|
|
/* else use the digraph key */
|
|
return dp->dig;
|
|
}
|
|
|
|
/* this function lists or defines digraphs */
|
|
void do_digraph(bang, extra)
|
|
int bang;
|
|
char extra[];
|
|
{
|
|
int dig;
|
|
REG struct _DIG *dp;
|
|
struct _DIG *prev;
|
|
static int user_defined = FALSE; /* boolean: are all later digraphs user-defined? */
|
|
char listbuf[8];
|
|
|
|
/* if "extra" is NULL, then we've reached the end of the built-ins */
|
|
if (!extra)
|
|
{
|
|
user_defined = TRUE;
|
|
return;
|
|
}
|
|
|
|
/* if no args, then display the existing digraphs */
|
|
if (*extra < ' ')
|
|
{
|
|
listbuf[0] = listbuf[1] = listbuf[2] = listbuf[5] = ' ';
|
|
listbuf[7] = '\0';
|
|
for (dig = 0, dp = digs; dp; dp = dp->next)
|
|
{
|
|
if (dp->save || bang)
|
|
{
|
|
dig += 7;
|
|
if (dig >= COLS)
|
|
{
|
|
addch('\n');
|
|
exrefresh();
|
|
dig = 7;
|
|
}
|
|
listbuf[3] = dp->key1;
|
|
listbuf[4] = dp->key2;
|
|
listbuf[6] = dp->dig;
|
|
qaddstr(listbuf);
|
|
}
|
|
}
|
|
addch('\n');
|
|
exrefresh();
|
|
return;
|
|
}
|
|
|
|
/* make sure we have at least two characters */
|
|
if (!extra[1])
|
|
{
|
|
msg("Digraphs must be composed of two characters");
|
|
return;
|
|
}
|
|
|
|
/* sort key1 and key2, so that their original order won't matter */
|
|
if (extra[0] > extra[1])
|
|
{
|
|
dig = extra[0];
|
|
extra[0] = extra[1];
|
|
extra[1] = dig;
|
|
}
|
|
|
|
/* locate the new digraph character */
|
|
for (dig = 2; extra[dig] == ' ' || extra[dig] == '\t'; dig++)
|
|
{
|
|
}
|
|
dig = extra[dig];
|
|
if (!bang && dig)
|
|
{
|
|
dig |= 0x80;
|
|
}
|
|
|
|
/* search for the digraph */
|
|
for (prev = (struct _DIG *)0, dp = digs;
|
|
dp && (dp->key1 != extra[0] || dp->key2 != extra[1]);
|
|
prev = dp, dp = dp->next)
|
|
{
|
|
}
|
|
|
|
/* deleting the digraph? */
|
|
if (!dig)
|
|
{
|
|
if (!dp)
|
|
{
|
|
#ifndef CRUNCH
|
|
msg("%c%c not a digraph", extra[0], extra[1]);
|
|
#endif
|
|
return;
|
|
}
|
|
if (prev)
|
|
prev->next = dp->next;
|
|
else
|
|
digs = dp->next;
|
|
free(dp);
|
|
return;
|
|
}
|
|
|
|
/* if necessary, create a new digraph struct for the new digraph */
|
|
if (dig && !dp)
|
|
{
|
|
dp = (struct _DIG *)malloc(sizeof *dp);
|
|
if (!dp)
|
|
{
|
|
msg("Out of space in the digraph table");
|
|
return;
|
|
}
|
|
if (prev)
|
|
prev->next = dp;
|
|
else
|
|
digs = dp;
|
|
dp->next = (struct _DIG *)0;
|
|
}
|
|
|
|
/* assign it the new digraph value */
|
|
dp->key1 = extra[0];
|
|
dp->key2 = extra[1];
|
|
dp->dig = dig;
|
|
dp->save = user_defined;
|
|
}
|
|
|
|
# ifndef NO_MKEXRC
|
|
void savedigs(fd)
|
|
int fd;
|
|
{
|
|
static char buf[] = "digraph! XX Y\n";
|
|
REG struct _DIG *dp;
|
|
|
|
for (dp = digs; dp; dp = dp->next)
|
|
{
|
|
if (dp->save)
|
|
{
|
|
buf[9] = dp->key1;
|
|
buf[10] = dp->key2;
|
|
buf[12] = dp->dig;
|
|
write(fd, buf, (unsigned)14);
|
|
}
|
|
}
|
|
}
|
|
# endif
|
|
#endif
|
|
|
|
|
|
/* This function allows the user to replace an existing (possibly zero-length)
|
|
* chunk of text with typed-in text. It returns the MARK of the last character
|
|
* that the user typed in.
|
|
*/
|
|
MARK input(from, to, when, above)
|
|
MARK from; /* where to start inserting text */
|
|
MARK to; /* extent of text to delete */
|
|
int when; /* either WHEN_VIINP or WHEN_VIREP */
|
|
int above; /* boolean: take indentation from lower line? */
|
|
{
|
|
char key[2]; /* key char followed by '\0' char */
|
|
char *build; /* used in building a newline+indent string */
|
|
char *scan; /* used while looking at the indent chars of a line */
|
|
MARK m; /* some place in the text */
|
|
#ifndef NO_EXTENSIONS
|
|
int quit = FALSE; /* boolean: are we exiting after this? */
|
|
int inchg; /* boolean: have we done a "beforedo()" yet? */
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
/* if "from" and "to" are reversed, complain */
|
|
if (from > to)
|
|
{
|
|
msg("ERROR: input(%ld:%d, %ld:%d)",
|
|
markline(from), markidx(from),
|
|
markline(to), markidx(to));
|
|
return MARK_UNSET;
|
|
}
|
|
#endif
|
|
|
|
key[1] = 0;
|
|
|
|
/* if we're replacing text with new text, save the old stuff */
|
|
/* (Alas, there is no easy way to save text for replace mode) */
|
|
if (from != to)
|
|
{
|
|
cut(from, to);
|
|
}
|
|
|
|
/* if doing a dot command, then reuse the previous text */
|
|
if (doingdot)
|
|
{
|
|
ChangeText
|
|
{
|
|
/* delete the text that's there now */
|
|
if (from != to)
|
|
{
|
|
delete(from, to);
|
|
}
|
|
|
|
/* insert the previous text */
|
|
cutname('.');
|
|
cursor = paste(from, FALSE, TRUE) + 1L;
|
|
}
|
|
}
|
|
else /* interactive version */
|
|
{
|
|
/* assume that whoever called this already did a beforedo() */
|
|
#ifndef NO_EXTENSIONS
|
|
inchg = TRUE;
|
|
#endif
|
|
|
|
/* if doing a change within the line... */
|
|
if (from != to && markline(from) == markline(to))
|
|
{
|
|
/* mark the end of the text with a "$" */
|
|
change(to - 1, to, "$");
|
|
}
|
|
else
|
|
{
|
|
/* delete the old text right off */
|
|
if (from != to)
|
|
{
|
|
delete(from, to);
|
|
}
|
|
to = from;
|
|
}
|
|
|
|
/* handle autoindent of the first line, maybe */
|
|
cursor = from;
|
|
m = (above ? (cursor + BLKSIZE) : (cursor - BLKSIZE));
|
|
if (*o_autoindent && markidx(m) == 0
|
|
&& markline(m) >= 1L && markline(m) <= nlines)
|
|
{
|
|
/* Only autoindent blank lines. */
|
|
pfetch(markline(cursor));
|
|
if (plen == 0)
|
|
{
|
|
/* Okay, we really want to autoindent */
|
|
pfetch(markline(m));
|
|
for (scan = ptext, build = tmpblk.c;
|
|
*scan == ' ' || *scan == '\t';
|
|
)
|
|
{
|
|
*build++ = *scan++;
|
|
}
|
|
if (build > tmpblk.c)
|
|
{
|
|
*build = '\0';
|
|
add(cursor, tmpblk.c);
|
|
cursor += (build - tmpblk.c);
|
|
if (cursor > to)
|
|
to = cursor;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* repeatedly add characters from the user */
|
|
for (;;)
|
|
{
|
|
/* Get a character */
|
|
redraw(cursor, TRUE);
|
|
#ifdef DEBUG2
|
|
msg("cursor=%ld.%d, to=%ld.%d",
|
|
markline(cursor), markidx(cursor),
|
|
markline(to), markidx(to));
|
|
#endif
|
|
#ifndef NO_ABBR
|
|
pfetch(markline(cursor));
|
|
build = ptext;
|
|
if (pline == markline(from))
|
|
build += markidx(from);
|
|
for (scan = ptext + markidx(cursor); --scan >= build && isalnum(*scan); )
|
|
{
|
|
}
|
|
scan++;
|
|
key[0] = getabkey(when, scan, (int)(ptext + markidx(cursor) - scan));
|
|
#else
|
|
key[0] = getkey(when);
|
|
#endif
|
|
#ifndef NO_VISIBLE
|
|
if (key[0] != '\0' && V_from != MARK_UNSET)
|
|
{
|
|
msg("Can't modify text during a selection");
|
|
beep();
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_EXTENSIONS
|
|
if (key[0] == ctrl('O'))
|
|
{
|
|
if (inchg)
|
|
{
|
|
if (cursor < to)
|
|
{
|
|
delete(cursor, to);
|
|
redraw(cursor, TRUE);
|
|
}
|
|
afterdo();
|
|
inchg = FALSE;
|
|
}
|
|
}
|
|
else if (key[0] != ctrl('['))
|
|
{
|
|
if (!inchg)
|
|
{
|
|
beforedo(FALSE);
|
|
inchg = TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef CRUNCH
|
|
/* if wrapmargin is set & we're past the
|
|
* warpmargin, then change the last whitespace
|
|
* characters on line into a newline
|
|
*/
|
|
if (*o_wrapmargin != 0)
|
|
{
|
|
pfetch(markline(cursor));
|
|
if (idx2col(cursor, ptext, TRUE) > COLS - (*o_wrapmargin & 0xff))
|
|
{
|
|
build = tmpblk.c;
|
|
*build++ = '\n';
|
|
if (*o_autoindent)
|
|
{
|
|
/* figure out indent for next line */
|
|
for (scan = ptext; *scan == ' ' || *scan == '\t'; )
|
|
{
|
|
*build++ = *scan++;
|
|
}
|
|
}
|
|
*build = '\0';
|
|
|
|
scan = ptext + plen;
|
|
m = cursor & ~(BLKSIZE - 1);
|
|
while (ptext < scan)
|
|
{
|
|
scan--;
|
|
if (*scan != ' ' && *scan != '\t')
|
|
continue;
|
|
|
|
/*break up line, and we do autoindent if needed*/
|
|
change(m + (scan - ptext), m + (scan - ptext) + 1, tmpblk.c);
|
|
cursor = (cursor & ~(BLKSIZE - 1))
|
|
+ BLKSIZE
|
|
+ strlen(tmpblk.c) - 1
|
|
+ plen - (scan - ptext) - 1;
|
|
|
|
/*remove trailing spaces on previous line*/
|
|
pfetch(markline(m));
|
|
scan = ptext + plen;
|
|
while (ptext < scan)
|
|
{
|
|
scan--;
|
|
if (*scan != ' ' && *scan != '\t')
|
|
break;
|
|
}
|
|
delete(m + (scan-ptext) + 1, m + plen);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif /* !CRUNCH */
|
|
|
|
/* process it */
|
|
switch (*key)
|
|
{
|
|
#ifndef NO_EXTENSIONS
|
|
case ctrl('O'): /* special movement mapped keys */
|
|
*key = getkey(0);
|
|
switch (*key)
|
|
{
|
|
case 'h': m = m_left(cursor, 0L); break;
|
|
case 'j':
|
|
case 'k': m = m_updnto(cursor, 0L, *key); break;
|
|
case 'l': m = cursor + 1; break;
|
|
case 'B':
|
|
case 'b': m = m_bword(cursor, 0L, *key); break;
|
|
case 'W':
|
|
case 'w': m = m_fword(cursor, 0L, *key, '\0'); break;
|
|
case '^': m = m_front(cursor, 0L); break;
|
|
case '$': m = m_rear(cursor, 0L); break;
|
|
case ctrl('B'):
|
|
case ctrl('F'):
|
|
m = m_scroll(cursor, 0L, *key); break;
|
|
case 'x':
|
|
#ifndef NO_VISIBLE
|
|
if (V_from)
|
|
beep();
|
|
else
|
|
#endif
|
|
ChangeText
|
|
{
|
|
m = v_xchar(cursor, 0L, 'x');
|
|
}
|
|
break;
|
|
case 'i': m = to = from = cursor;
|
|
when = WHEN_VIINP + WHEN_VIREP - when;
|
|
break;
|
|
case 'K':
|
|
pfetch(markline(cursor));
|
|
changes++; /* <- after this, we can alter ptext */
|
|
ptext[markidx(cursor)] = 0;
|
|
for (scan = ptext + markidx(cursor) - 1;
|
|
scan >= ptext && isalnum(*scan);
|
|
scan--)
|
|
{
|
|
}
|
|
scan++;
|
|
m = (*scan ? v_keyword(scan, cursor, 0L) : cursor);
|
|
break;
|
|
|
|
# ifndef NO_VISIBLE
|
|
case 'v':
|
|
case 'V':
|
|
if (V_from)
|
|
V_from = MARK_UNSET;
|
|
else
|
|
V_from = cursor;
|
|
m = from = to = cursor;
|
|
V_linemd = (*key == 'V');
|
|
break;
|
|
|
|
case 'd':
|
|
case 'y':
|
|
case '\\':
|
|
/* do nothing if unmarked */
|
|
if (!V_from)
|
|
{
|
|
msg("You must mark the text first");
|
|
beep();
|
|
break;
|
|
}
|
|
|
|
/* "from" must come before "to" */
|
|
if (V_from < cursor)
|
|
{
|
|
from = V_from;
|
|
to = cursor;
|
|
}
|
|
else
|
|
{
|
|
from = cursor;
|
|
to = V_from;
|
|
}
|
|
|
|
/* we don't need V_from anymore */
|
|
V_from = MARK_UNSET;
|
|
|
|
if (V_linemd)
|
|
{
|
|
/* adjust for line mode */
|
|
from &= ~(BLKSIZE - 1);
|
|
to |= (BLKSIZE - 1);
|
|
}
|
|
else
|
|
{
|
|
/* in character mode, we must
|
|
* worry about deleting the newline
|
|
* at the end of the last line
|
|
*/
|
|
pfetch(markline(to));
|
|
if (markidx(to) == plen)
|
|
to |= (BLKSIZE - 1);
|
|
}
|
|
to++;
|
|
|
|
switch (*key)
|
|
{
|
|
case 'y':
|
|
cut(from, to);
|
|
break;
|
|
|
|
case 'd':
|
|
ChangeText
|
|
{
|
|
cut(from, to);
|
|
delete(from, to);
|
|
}
|
|
cursor = from;
|
|
break;
|
|
|
|
#ifndef NO_POPUP
|
|
case '\\':
|
|
ChangeText
|
|
{
|
|
cursor = v_popup(from, to);
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
m = from = to = cursor;
|
|
break;
|
|
|
|
case 'p':
|
|
case 'P':
|
|
V_from = MARK_UNSET;
|
|
ChangeText
|
|
{
|
|
m = from = to = cursor = paste(cursor, (*key == 'p'), FALSE);
|
|
}
|
|
break;
|
|
# endif /* !NO_VISIBLE */
|
|
default: m = MARK_UNSET;
|
|
}
|
|
|
|
/* adjust the moved cursor */
|
|
if (m != cursor)
|
|
{
|
|
m = adjmove(cursor, m, (*key == 'j' || *key == 'k' ? 0x20 : 0));
|
|
if (*key == '$' || (*key == 'l' && m <= cursor))
|
|
{
|
|
m++;
|
|
}
|
|
}
|
|
|
|
/* if the cursor is reasonable, use it */
|
|
if (m == MARK_UNSET)
|
|
{
|
|
beep();
|
|
}
|
|
else
|
|
{
|
|
from = to = cursor = m;
|
|
}
|
|
break;
|
|
|
|
case ctrl('Z'):
|
|
if (getkey(0) == ctrl('Z'))
|
|
{
|
|
quit = TRUE;
|
|
goto BreakBreak;
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case ctrl('['):
|
|
/* if last line contains only whitespace, then remove whitespace */
|
|
if (*o_autoindent)
|
|
{
|
|
pfetch(markline(cursor));
|
|
for (scan = ptext; isspace(*scan); scan++)
|
|
{
|
|
}
|
|
if (scan > ptext && !*scan)
|
|
{
|
|
cursor &= ~(BLKSIZE - 1L);
|
|
if (to < cursor + plen)
|
|
{
|
|
to = cursor + plen;
|
|
}
|
|
}
|
|
}
|
|
goto BreakBreak;
|
|
|
|
case ctrl('U'):
|
|
if (markline(cursor) == markline(from))
|
|
{
|
|
cursor = from;
|
|
}
|
|
else
|
|
{
|
|
cursor &= ~(BLKSIZE - 1);
|
|
}
|
|
break;
|
|
|
|
case ctrl('D'):
|
|
case ctrl('T'):
|
|
if (to > cursor)
|
|
{
|
|
delete(cursor, to);
|
|
}
|
|
mark[27] = cursor;
|
|
cmd_shift(cursor, cursor, *key == ctrl('D') ? CMD_SHIFTL : CMD_SHIFTR, TRUE, "");
|
|
if (mark[27])
|
|
{
|
|
cursor = mark[27];
|
|
}
|
|
else
|
|
{
|
|
cursor = m_front(cursor, 0L);
|
|
}
|
|
to = cursor;
|
|
break;
|
|
|
|
case '\b':
|
|
if (cursor <= from)
|
|
{
|
|
beep();
|
|
}
|
|
else if (markidx(cursor) == 0)
|
|
{
|
|
cursor -= BLKSIZE;
|
|
pfetch(markline(cursor));
|
|
cursor += plen;
|
|
}
|
|
else
|
|
{
|
|
cursor--;
|
|
}
|
|
break;
|
|
|
|
case ctrl('W'):
|
|
m = m_bword(cursor, 1L, 'b');
|
|
if (markline(m) == markline(cursor) && m >= from)
|
|
{
|
|
cursor = m;
|
|
if (from > cursor)
|
|
{
|
|
from = cursor;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
beep();
|
|
}
|
|
break;
|
|
|
|
case '\n':
|
|
#if OSK
|
|
case '\l':
|
|
#else
|
|
case '\r':
|
|
#endif
|
|
build = tmpblk.c;
|
|
*build++ = '\n';
|
|
if (*o_autoindent)
|
|
{
|
|
/* figure out indent for next line */
|
|
pfetch(markline(cursor));
|
|
for (scan = ptext; *scan == ' ' || *scan == '\t'; )
|
|
{
|
|
*build++ = *scan++;
|
|
}
|
|
|
|
/* remove indent from this line, if blank */
|
|
if ((scan - ptext) >= markidx(cursor) && plen > 0)
|
|
{
|
|
to = cursor &= ~(BLKSIZE - 1);
|
|
delete(cursor, cursor + plen);
|
|
}
|
|
}
|
|
*build = 0;
|
|
if (cursor >= to && when != WHEN_VIREP)
|
|
{
|
|
add(cursor, tmpblk.c);
|
|
}
|
|
else
|
|
{
|
|
change(cursor, to, tmpblk.c);
|
|
}
|
|
redraw(cursor, TRUE);
|
|
to = cursor = (cursor & ~(BLKSIZE - 1))
|
|
+ BLKSIZE
|
|
+ (int)(build - tmpblk.c) - 1;
|
|
break;
|
|
|
|
case ctrl('A'):
|
|
case ctrl('P'):
|
|
if (cursor < to)
|
|
{
|
|
delete(cursor, to);
|
|
}
|
|
if (*key == ctrl('A'))
|
|
{
|
|
cutname('.');
|
|
}
|
|
to = cursor = paste(cursor, FALSE, TRUE) + 1L;
|
|
break;
|
|
|
|
case ctrl('V'):
|
|
if (cursor >= to && when != WHEN_VIREP)
|
|
{
|
|
add(cursor, "^");
|
|
}
|
|
else
|
|
{
|
|
change(cursor, to, "^");
|
|
to = cursor + 1;
|
|
}
|
|
redraw(cursor, TRUE);
|
|
*key = getkey(0);
|
|
if (*key == '\n')
|
|
{
|
|
/* '\n' too hard to handle */
|
|
#if OSK
|
|
*key = '\l';
|
|
#else
|
|
*key = '\r';
|
|
#endif
|
|
}
|
|
change(cursor, cursor + 1, key);
|
|
cursor++;
|
|
if (cursor > to)
|
|
{
|
|
to = cursor;
|
|
}
|
|
break;
|
|
|
|
case ctrl('L'):
|
|
case ctrl('R'):
|
|
redraw(MARK_UNSET, FALSE);
|
|
break;
|
|
|
|
default:
|
|
if (cursor >= to && when != WHEN_VIREP)
|
|
{
|
|
add(cursor, key);
|
|
cursor++;
|
|
to = cursor;
|
|
}
|
|
else
|
|
{
|
|
pfetch(markline(cursor));
|
|
if (markidx(cursor) == plen)
|
|
{
|
|
add(cursor, key);
|
|
}
|
|
else
|
|
{
|
|
#ifndef NO_DIGRAPH
|
|
*key = digraph(ptext[markidx(cursor)], *key);
|
|
#endif
|
|
change(cursor, cursor + 1, key);
|
|
}
|
|
cursor++;
|
|
}
|
|
#ifndef NO_SHOWMATCH
|
|
/* show matching "({[" if necessary */
|
|
if (*o_showmatch && strchr(")}]", *key))
|
|
{
|
|
redraw(cursor, TRUE);
|
|
m = m_match(cursor - 1, 0L);
|
|
if (markline(m) >= topline
|
|
&& markline(m) <= botline)
|
|
{
|
|
redraw(m, TRUE);
|
|
refresh();
|
|
sleep(1);
|
|
}
|
|
}
|
|
#endif
|
|
} /* end switch(*key) */
|
|
} /* end for(;;) */
|
|
BreakBreak:;
|
|
/* delete any excess characters */
|
|
if (cursor < to)
|
|
{
|
|
#ifndef NO_EXTENSIONS
|
|
/* if we aren't in the middle of a change, start one! */
|
|
if (!inchg)
|
|
{
|
|
beforedo(FALSE);
|
|
inchg = TRUE;
|
|
}
|
|
#endif
|
|
delete(cursor, to);
|
|
}
|
|
|
|
} /* end if doingdot else */
|
|
|
|
/* put the new text into a cut buffer for possible reuse */
|
|
if (!doingdot)
|
|
{
|
|
blksync();
|
|
cutname('.');
|
|
cut(from, cursor);
|
|
}
|
|
|
|
/* move to last char that we inputted, unless it was newline */
|
|
if (markidx(cursor) != 0)
|
|
{
|
|
cursor--;
|
|
}
|
|
redraw(cursor, FALSE);
|
|
|
|
#ifndef NO_EXTENSIONS
|
|
if (quit)
|
|
{
|
|
/* if this is a nested "do", then cut it short */
|
|
abortdo();
|
|
|
|
/* exit, unless we can't write out the file */
|
|
cursor = v_xit(cursor, 0L, 'Z');
|
|
}
|
|
#endif
|
|
|
|
rptlines = 0L;
|
|
return cursor;
|
|
}
|