/*
* Clear to the end of the current physical line
*/
void
vclreol(void)
{
register int i, j;
register cell *tp;
if (destcol == WCOLS)
return;
destline += destcol / WCOLS;
destcol %= WCOLS;
if (destline < 0 || destline > WECHO)
error(catgets(catd, 1, 237, "Internal error: vclreol"));
i = WCOLS - destcol;
tp = vtube[destline] + destcol;
if (CE) {
if (IN && *tp || !ateopr()) {
vcsync();
vputp(CE, 1);
}
vclrcell(tp, i);
return;
}
if (*tp == 0)
return;
while (i > 0 && (j = *tp & (QUOTE|TRIM|MULTICOL))) {
if ((j != ' ' && (j & QUOTE) == 0)) {
destcol = WCOLS - i;
vputchar(' ');
}
--i, *tp++ = 0;
}
}
/*
* Clear to the end of the current physical line
*/
void
vclreol(void)
{
int i;
wchar_t *tp, j;
#ifdef TRACE
if (trace)
fprintf(trace, "vclreol(), destcol %d, ateopr() %d\n", destcol, ateopr());
#endif
if (destcol == WCOLS)
return;
destline += destcol / WCOLS;
destcol %= WCOLS;
if (destline < 0 || destline > WECHO)
error(gettext("Internal error: vclreol"));
i = WCOLS - destcol;
tp = vtube[destline] + destcol;
if (clr_eol) {
if (insert_null_glitch && *tp || !ateopr()) {
vcsync();
vputp(clr_eol, 1);
}
vclrbyte(tp, i);
return;
}
if (*tp == 0)
return;
while (i > 0 && (j = *tp & (QUOTE|TRIM))) {
if (j != ' ' && (j & QUOTE) == 0) {
destcol = WCOLS - i;
(void) vputchar(' ');
}
--i, *tp++ = 0;
}
}
void
vappend(int ch, int cnt, int indent)
{
register int i;
register char *gcursor;
bool escape;
int repcnt;
short oldhold = hold;
/*
* Before a move in hardopen when the line is dirty
* or we are in the middle of the printed representation,
* we retype the line to the left of the cursor so the
* insert looks clean.
*/
if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
rubble = 1;
wcursor = cursor;
vmove();
}
vaifirst = indent == 0;
/*
* Handle replace character by (eventually)
* limiting the number of input characters allowed
* in the vgetline routine.
*/
if (ch == 'r')
repcnt = 2;
else
repcnt = 0;
/*
* If an autoindent is specified, then
* generate a mixture of blanks to tabs to implement
* it and place the cursor after the indent.
* Text read by the vgetline routine will be placed in genbuf,
* so the indent is generated there.
*/
if (value(AUTOINDENT) && indent != 0) {
gcursor = genindent(indent);
*gcursor = 0;
vgotoCL(qcolumn(cursor - 1, genbuf));
} else {
gcursor = genbuf;
*gcursor = 0;
if (ch == 'o')
vfixcurs();
}
/*
* Prepare for undo. Pointers delimit inserted portion of line.
*/
vUA1 = vUA2 = cursor;
/*
* If we are not in a repeated command and a ^@ comes in
* then this means the previous inserted text.
* If there is none or it was too long to be saved,
* then beep() and also arrange to undo any damage done
* so far (e.g. if we are a change.)
*/
if ((vglobp && *vglobp == 0) || peekbr()) {
if ((INS[0] & (OVERBUF|TRIM)) == OVERBUF) {
beep();
if (!splitw)
ungetkey('u');
doomed = 0;
hold = oldhold;
return;
}
/*
* Unread input from INS.
* An escape will be generated at end of string.
* Hold off n^^2 type update on dumb terminals.
*/
vglobp = INS;
hold |= HOLDQIK;
} else if (vglobp == 0)
/*
* Not a repeated command, get
* a new inserted text for repeat.
*/
INS[0] = 0;
/*
* For wrapmargin to hack away second space after a '.'
* when the first space caused a line break we keep
* track that this happened in gobblebl, which says
* to gobble up a blank silently.
*/
gobblebl = 0;
/*
* Text gathering loop.
* New text goes into genbuf starting at gcursor.
* cursor preserves place in linebuf where text will eventually go.
*/
if (*cursor == 0 || state == CRTOPEN)
hold |= HOLDROL;
for (;;) {
if (ch == 'r' && repcnt == 0)
escape = 0;
else {
gcursor = vgetline(repcnt, gcursor, &escape);
/*
* After an append, stick information
* about the ^D's and ^^D's and 0^D's in
* the repeated text buffer so repeated
* inserts of stuff indented with ^D as backtab's
* can work.
*/
if (HADUP)
addtext("^");
else if (HADZERO)
addtext("0");
while (CDCNT > 0)
addtext("\204"), CDCNT--;
if (gobbled)
addtext(" ");
addtext(ogcursor);
}
repcnt = 0;
/*
* Smash the generated and preexisting indents together
* and generate one cleanly made out of tabs and spaces
* if we are using autoindent.
*/
if (!vaifirst && value(AUTOINDENT)) {
i = fixindent(indent);
if (!HADUP)
indent = i;
gcursor = strend(genbuf);
}
/*
* Limit the repetition count based on maximum
* possible line length; do output implied
* by further count (> 1) and cons up the new line
* in linebuf.
*/
cnt = vmaxrep(ch, cnt);
CP(gcursor + 1, cursor);
do {
CP(cursor, genbuf);
if (cnt > 1) {
int oldhold = hold;
Outchar = vinschar;
hold |= HOLDQIK;
ex_printf("%s", genbuf);
hold = oldhold;
Outchar = vputchar;
}
cursor += gcursor - genbuf;
} while (--cnt > 0);
endim();
vUA2 = cursor;
if (escape != '\n')
CP(cursor, gcursor + 1);
/*
* If doomed characters remain, clobber them,
* and reopen the line to get the display exact.
*/
if (state != HARDOPEN) {
DEPTH(vcline) = 0;
if (doomed > 0) {
register int cind = cindent();
physdc(cind, cind + doomed);
doomed = 0;
}
i = vreopen(LINE(vcline), lineDOT(), vcline);
}
/*
* All done unless we are continuing on to another line.
*/
if (escape != '\n')
break;
/*
* Set up for the new line.
* First save the current line, then construct a new
* first image for the continuation line consisting
* of any new autoindent plus the pushed ahead text.
*/
killU();
addtext(gobblebl ? " " : "\n");
vsave();
cnt = 1;
if (value(AUTOINDENT)) {
#ifdef LISP
if (value(LISP))
indent = lindent(dot + 1);
else
#endif
if (!HADUP && vaifirst)
indent = whitecnt(linebuf);
vaifirst = 0;
strcLIN(vpastwh(gcursor + 1));
gcursor = genindent(indent);
*gcursor = 0;
if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
gcursor = genbuf;
CP(gcursor, linebuf);
} else {
CP(genbuf, gcursor + 1);
gcursor = genbuf;
}
/*
* If we started out as a single line operation and are now
* turning into a multi-line change, then we had better yank
* out dot before it changes so that undo will work
* correctly later.
*/
if (vundkind == VCHNG) {
vremote(1, (void (*)(int))yank, 0);
undap1--;
}
/*
* Now do the append of the new line in the buffer,
* and update the display. If slowopen
* we don't do very much.
*/
vdoappend(genbuf);
vundkind = VMANYINS;
vcline++;
if (state != VISUAL)
vshow(dot, NOLINE);
else {
i += LINE(vcline - 1);
vopen(dot, i);
if (value(SLOWOPEN))
vscrap();
else
vsync1(LINE(vcline));
}
strcLIN(gcursor);
*gcursor = 0;
cursor = linebuf;
vgotoCL(qcolumn(cursor - 1, genbuf));
}
/*
* All done with insertion, position the cursor
* and sync the screen.
*/
hold = oldhold;
if (cursor > linebuf)
cursor--;
if (state != HARDOPEN)
vsyncCL();
else if (cursor > linebuf)
back1();
doomed = 0;
wcursor = cursor;
vmove();
}
/*
* Main loop for command mode command decoding.
* A few commands are executed here, but main function
* is to strip command addresses, do a little address oriented
* processing and call command routines to do the real work.
*/
void
commands(bool noprompt, bool exitoneof)
{
register line *addr;
register int c;
register int lchng;
int given;
int seensemi;
int cnt;
bool hadpr;
resetflav();
nochng();
for (;;) {
/*
* If dot at last command
* ended up at zero, advance to one if there is a such.
*/
if (dot <= zero) {
dot = zero;
if (dol > zero)
dot = one;
}
shudclob = 0;
/*
* If autoprint or trailing print flags,
* print the line at the specified offset
* before the next command.
*/
if (pflag ||
(lchng != chng && value(AUTOPRINT) && !inglobal && !inopen && endline)) {
pflag = 0;
nochng();
if (dol != zero) {
addr1 = addr2 = dot + poffset;
if (addr1 < one || addr1 > dol)
error("Offset out-of-bounds|Offset after command too large");
setdot1();
goto print;
}
}
nochng();
/*
* Print prompt if appropriate.
* If not in global flush output first to prevent
* going into pfast mode unreasonably.
*/
if (inglobal == 0) {
flush();
if (!hush && value(PROMPT) && !globp && !noprompt && endline) {
ex_putchar(':');
hadpr = 1;
}
TSYNC();
}
/*
* Gobble up the address.
* Degenerate addresses yield ".".
*/
addr2 = 0;
given = seensemi = 0;
do {
addr1 = addr2;
addr = address(0);
c = getcd();
if (addr == 0) {
if (c == ',')
addr = dot;
else if (addr1 != 0) {
addr2 = dot;
break;
} else
break;
}
addr2 = addr;
given++;
if (c == ';') {
c = ',';
dot = addr;
seensemi = 1;
}
} while (c == ',');
if (c == '%') {
/* %: same as 1,$ */
addr1 = one;
addr2 = dol;
given = 2;
c = ex_getchar();
}
if (addr1 == 0)
addr1 = addr2;
if (c == ':')
c = ex_getchar();
/*
* Set command name for special character commands.
*/
tailspec(c);
/*
* If called via : escape from open or visual, limit
* the set of available commands here to save work below.
*/
if (inopen) {
if (c=='\n' || c=='\r' || c==CTRL('d') || c==EOF) {
if (addr2)
dot = addr2;
if (c == EOF)
return;
continue;
}
if (any(c, "o"))
notinvis:
tailprim(Command, 1, 1);
}
switch (c) {
case 'a':
switch(peekchar()) {
case 'b':
/* abbreviate */
tail("abbreviate");
setnoaddr();
mapcmd(0, 1);
anyabbrs = 1;
continue;
case 'r':
/* args */
tail("args");
setnoaddr();
eol();
pargs();
continue;
}
/* append */
if (inopen)
goto notinvis;
tail("append");
setdot();
aiflag = exclam();
ex_newline();
vmacchng(0);
deletenone();
setin(addr2);
inappend = 1;
ignore(append(gettty, addr2));
inappend = 0;
nochng();
continue;
case 'c':
switch (peekchar()) {
/* copy */
case 'o':
tail("copy");
vmacchng(0);
move();
continue;
#ifdef CHDIR
/* cd */
case 'd':
tail("cd");
goto changdir;
/* chdir */
case 'h':
ignchar();
if (peekchar() == 'd') {
register char *p;
tail2of("chdir");
changdir:
if (savedfile[0] == '/' || !value(WARN))
ignore(exclam());
else
ignore(quickly());
if (skipend()) {
p = getenv("HOME");
if (p == NULL)
error("Home directory unknown");
} else
getone(), p = file;
eol();
if (chdir(p) < 0)
filioerr(p);
if (savedfile[0] != '/')
edited = 0;
continue;
}
if (inopen)
tailprim("change", 2, 1);
tail2of("change");
break;
#endif
default:
if (inopen)
goto notinvis;
tail("change");
break;
}
/* change */
aiflag = exclam();
setCNL();
vmacchng(0);
setin(addr1);
delete(0);
inappend = 1;
ignore(append(gettty, addr1 - 1));
inappend = 0;
nochng();
continue;
/* delete */
case 'd':
/*
* Caution: dp and dl have special meaning already.
*/
tail("delete");
c = cmdreg();
setCNL();
vmacchng(0);
if (c)
YANKreg(c);
delete(0);
appendnone();
continue;
/* edit */
/* ex */
case 'e':
tail(peekchar() == 'x' ? "ex" : "edit");
editcmd:
if (!exclam() && chng)
c = 'E';
filename(c);
if (c == 'E') {
ungetchar(lastchar());
ignore(quickly());
}
setnoaddr();
doecmd:
init();
addr2 = zero;
laste++;
ex_sync();
rop(c);
nochng();
continue;
/* file */
case 'f':
tail("file");
setnoaddr();
filename(c);
noonl();
/*
synctmp();
*/
continue;
/* global */
case 'g':
tail("global");
global(!exclam());
nochng();
continue;
/* insert */
case 'i':
if (inopen)
goto notinvis;
tail("insert");
setdot();
nonzero();
aiflag = exclam();
ex_newline();
vmacchng(0);
deletenone();
setin(addr2);
inappend = 1;
ignore(append(gettty, addr2 - 1));
inappend = 0;
if (dot == zero && dol > zero)
dot = one;
nochng();
continue;
/* join */
case 'j':
tail("join");
c = exclam();
setcount();
nonzero();
ex_newline();
vmacchng(0);
if (given < 2 && addr2 != dol)
addr2++;
join(c);
continue;
/* k */
case 'k':
casek:
pastwh();
c = ex_getchar();
if (endcmd(c))
serror("Mark what?|%s requires following letter", Command);
ex_newline();
if (!islower(c))
error("Bad mark|Mark must specify a letter");
setdot();
nonzero();
names[c - 'a'] = *addr2 &~ 01;
anymarks = 1;
continue;
/* list */
case 'l':
tail("list");
setCNL();
ignorf(setlist(1));
pflag = 0;
goto print;
case 'm':
if (peekchar() == 'a') {
ignchar();
if (peekchar() == 'p') {
/* map */
tail2of("map");
setnoaddr();
mapcmd(0, 0);
continue;
}
/* mark */
tail2of("mark");
goto casek;
}
/* move */
tail("move");
vmacchng(0);
move();
continue;
case 'n':
if (peekchar() == 'u') {
tail("number");
goto numberit;
}
/* next */
tail("next");
setnoaddr();
ckaw();
ignore(quickly());
if (getargs())
makargs();
next();
c = 'e';
filename(c);
goto doecmd;
/* open */
case 'o':
tail("open");
oop();
pflag = 0;
nochng();
continue;
case 'p':
case 'P':
switch (peekchar()) {
/* put */
case 'u':
tail("put");
setdot();
c = cmdreg();
eol();
vmacchng(0);
if (c)
putreg(c);
else
put();
continue;
case 'r':
ignchar();
if (peekchar() == 'e') {
/* preserve */
tail2of("preserve");
eol();
if (preserve() == 0)
error("Preserve failed!");
else
error("File preserved.");
}
tail2of("print");
break;
default:
tail("print");
break;
}
/* print */
setCNL();
pflag = 0;
print:
nonzero();
if (CL && span() > EX_LINES) {
flush1();
vclear();
}
plines(addr1, addr2, 1);
continue;
/* quit */
case 'q':
tail("quit");
setnoaddr();
c = quickly();
eol();
if (!c)
quit:
nomore();
if (inopen) {
vgoto(WECHO, 0);
if (!ateopr())
vnfl();
else {
tostop();
}
flush();
setty(normf);
}
cleanup(1);
ex_exit(0);
case 'r':
if (peekchar() == 'e') {
ignchar();
switch (peekchar()) {
/* rewind */
case 'w':
tail2of("rewind");
setnoaddr();
if (!exclam()) {
ckaw();
if (chng && dol > zero)
error("No write@since last chage (:rewind! overrides)");
}
eol();
erewind();
next();
c = 'e';
ungetchar(lastchar());
filename(c);
goto doecmd;
/* recover */
case 'c':
tail2of("recover");
setnoaddr();
c = 'e';
if (!exclam() && chng)
c = 'E';
filename(c);
if (c == 'E') {
ungetchar(lastchar());
ignore(quickly());
}
init();
addr2 = zero;
laste++;
ex_sync();
recover();
rop2();
revocer();
if (status == 0)
rop3(c);
if (dol != zero)
change();
nochng();
continue;
}
tail2of("read");
} else
tail("read");
/* read */
if (savedfile[0] == 0 && dol == zero)
c = 'e';
pastwh();
vmacchng(0);
if (peekchar() == '!') {
setdot();
ignchar();
unix0(0);
filter(0);
continue;
}
filename(c);
rop(c);
nochng();
if (inopen && endline && addr1 > zero && addr1 < dol)
dot = addr1 + 1;
continue;
case 's':
switch (peekchar()) {
/*
* Caution: 2nd char cannot be c, g, or r
* because these have meaning to substitute.
*/
/* set */
case 'e':
tail("set");
setnoaddr();
set();
continue;
/* shell */
case 'h':
tail("shell");
setNAEOL();
vnfl();
putpad(TE);
flush();
unixwt(1, unixex("-i", (char *) 0, 0, 0));
vcontin(0);
continue;
/* source */
case 'o':
#ifdef notdef
if (inopen)
goto notinvis;
#endif
tail("source");
setnoaddr();
getone();
eol();
source(file, 0);
continue;
#ifdef SIGTSTP
/* stop, suspend */
case 't':
tail("stop");
goto suspend;
case 'u':
tail("suspend");
suspend:
if (!dosusp)
error("Old tty driver|Not using new tty driver/shell");
c = exclam();
eol();
if (!c)
ckaw();
onsusp(0);
continue;
#endif
}
/* fall into ... */
/* & */
/* ~ */
/* substitute */
case '&':
case '~':
Command = "substitute";
if (c == 's')
tail(Command);
vmacchng(0);
if (!substitute(c))
pflag = 0;
continue;
/* t */
case 't':
if (peekchar() == 'a') {
tail("tag");
tagfind(exclam());
if (!inopen)
lchng = chng - 1;
else
nochng();
continue;
}
tail("t");
vmacchng(0);
move();
continue;
case 'u':
if (peekchar() == 'n') {
ignchar();
switch(peekchar()) {
/* unmap */
case 'm':
tail2of("unmap");
setnoaddr();
mapcmd(1, 0);
continue;
/* unabbreviate */
case 'a':
tail2of("unabbreviate");
setnoaddr();
mapcmd(1, 1);
anyabbrs = 1;
continue;
}
/* undo */
tail2of("undo");
} else
tail("undo");
setnoaddr();
markDOT();
c = exclam();
ex_newline();
undo(c);
continue;
case 'v':
switch (peekchar()) {
case 'e':
/* version */
tail("version");
setNAEOL();
ex_printf("@(#) Version 3.6, 11/3/80"
" (4.0BSD). git "
"160803 14:24"
+5);
noonl();
continue;
/* visual */
case 'i':
tail("visual");
if (inopen) {
c = 'e';
goto editcmd;
}
vop();
pflag = 0;
nochng();
continue;
}
/* v */
tail("v");
global(0);
nochng();
continue;
/* write */
case 'w':
c = peekchar();
tail(c == 'q' ? "wq" : "write");
wq:
if (skipwh() && peekchar() == '!') {
pofix();
ignchar();
setall();
unix0(0);
filter(1);
} else {
setall();
wop(1);
nochng();
}
if (c == 'q')
goto quit;
continue;
/* xit */
case 'x':
tail("xit");
if (!chng)
goto quit;
c = 'q';
goto wq;
/* yank */
case 'y':
tail("yank");
c = cmdreg();
setcount();
eol();
vmacchng(0);
if (c)
YANKreg(c);
else
yank();
continue;
/* z */
case 'z':
zop(0);
pflag = 0;
continue;
/* * */
/* @ */
case '*':
case '@':
c = ex_getchar();
if (c=='\n' || c=='\r')
ungetchar(c);
if (any(c, "@*\n\r"))
c = lastmac;
if (isupper(c))
c = tolower(c);
if (!islower(c))
error("Bad register");
ex_newline();
setdot();
cmdmac(c);
continue;
/* | */
case '|':
endline = 0;
goto caseline;
/* \n */
case '\n':
endline = 1;
caseline:
notempty();
if (addr2 == 0) {
if (UP != NOSTR && c == '\n' && !inglobal)
c = CTRL('k');
if (inglobal)
addr1 = addr2 = dot;
else {
if (dot == dol)
error("At EOF|At end-of-file");
addr1 = addr2 = dot + 1;
}
}
setdot();
nonzero();
if (seensemi)
addr1 = addr2;
ex_getline(*addr1);
if (c == CTRL('k')) {
flush1();
destline--;
if (hadpr)
shudclob = 1;
}
plines(addr1, addr2, 1);
continue;
/* " */
case '"':
comment();
continue;
/* # */
case '#':
numberit:
setCNL();
ignorf(setnumb(1));
pflag = 0;
goto print;
/* = */
case '=':
ex_newline();
setall();
if (inglobal == 2)
pofix();
ex_printf("%d", lineno(addr2));
noonl();
continue;
/* ! */
case '!':
if (addr2 != 0) {
vmacchng(0);
unix0(0);
setdot();
filter(2);
} else {
unix0(1);
pofix();
putpad(TE);
flush();
unixwt(1, unixex("-c", uxb, 0, 0));
vclrech(1); /* vcontin(0); */
nochng();
}
continue;
/* < */
/* > */
case '<':
case '>':
for (cnt = 1; peekchar() == c; cnt++)
ignchar();
setCNL();
vmacchng(0);
shift(c, cnt);
continue;
/* ^D */
/* EOF */
case CTRL('d'):
case EOF:
if (exitoneof) {
if (addr2 != 0)
dot = addr2;
return;
}
if (!isatty(0)) {
if (intty)
/*
* Chtty sys call at UCB may cause a
* input which was a tty to suddenly be
* turned into /dev/null.
*/
onhup(0);
return;
}
if (addr2 != 0) {
setlastchar('\n');
putnl();
}
if (dol == zero) {
if (addr2 == 0)
putnl();
notempty();
}
ungetchar(EOF);
zop(hadpr);
continue;
default:
if (!isalpha(c))
break;
ungetchar(c);
tailprim("", 0, 0);
}
ierror("What?|Unknown command character '%c'", c);
}
}
void
vappend(int ch, int cnt, int indent)
{
int i;
unsigned char *gcursor;
bool escape;
int repcnt, savedoomed;
short oldhold = hold;
int savecnt = cnt;
line *startsrcline;
int startsrccol, endsrccol;
int gotNL = 0;
int imultlinecnt = 0;
int omultlinecnt = 0;
if ((savecnt > 1) && (ch == 'o' || ch == 'O')) {
omultlinecnt = 1;
}
#ifdef XPG6
if ((savecnt > 1) && (ch == 'a' || ch == 'A' || ch == 'i' || ch == 'I'))
imultlinecnt = 1;
#endif /* XPG6 */
/*
* Before a move in hardopen when the line is dirty
* or we are in the middle of the printed representation,
* we retype the line to the left of the cursor so the
* insert looks clean.
*/
if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
rubble = 1;
gcursor = cursor;
i = *gcursor;
*gcursor = ' ';
wcursor = gcursor;
(void) vmove();
*gcursor = i;
}
/*
* If vrep() passed indent = 0, this is the 'r' command,
* so don't autoindent until the last char.
*/
vaifirst = indent == 0;
/*
* Handle replace character by (eventually)
* limiting the number of input characters allowed
* in the vgetline routine.
*/
if (ch == 'r')
repcnt = 2;
else
repcnt = 0;
/*
* If an autoindent is specified, then
* generate a mixture of blanks to tabs to implement
* it and place the cursor after the indent.
* Text read by the vgetline routine will be placed in genbuf,
* so the indent is generated there.
*/
if (value(vi_AUTOINDENT) && indent != 0) {
unsigned char x;
gcursor = genindent(indent);
*gcursor = 0;
vgotoCL(nqcolumn(lastchr(linebuf, cursor), genbuf));
} else {
gcursor = genbuf;
*gcursor = 0;
if (ch == 'o')
vfixcurs();
}
/*
* Prepare for undo. Pointers delimit inserted portion of line.
*/
vUA1 = vUA2 = cursor;
/*
* If we are not in a repeated command and a ^@ comes in
* then this means the previous inserted text.
* If there is none or it was too long to be saved,
* then beep() and also arrange to undo any damage done
* so far (e.g. if we are a change.)
*/
switch (ch) {
case 'r':
break;
case 'a':
/*
* TRANSLATION_NOTE
* "A" is a terse mode message corresponding to
* "APPEND MODE".
* Translated message of "A" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("A"));
} else {
vshowmode(gettext("APPEND MODE"));
}
break;
case 's':
/*
* TRANSLATION_NOTE
* "S" is a terse mode message corresponding to
* "SUBSTITUTE MODE".
* Translated message of "S" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("S"));
} else {
vshowmode(gettext("SUBSTITUTE MODE"));
}
break;
case 'c':
/*
* TRANSLATION_NOTE
* "C" is a terse mode message corresponding to
* "CHANGE MODE".
* Translated message of "C" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("C"));
} else {
vshowmode(gettext("CHANGE MODE"));
}
break;
case 'R':
/*
* TRANSLATION_NOTE
* "R" is a terse mode message corresponding to
* "REPLACE MODE".
* Translated message of "R" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("R"));
} else {
vshowmode(gettext("REPLACE MODE"));
}
break;
case 'o':
/*
* TRANSLATION_NOTE
* "O" is a terse mode message corresponding to
* "OPEN MODE".
* Translated message of "O" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("O"));
} else {
vshowmode(gettext("OPEN MODE"));
}
break;
case 'i':
/*
* TRANSLATION_NOTE
* "I" is a terse mode message corresponding to
* "INSERT MODE" and the following "INPUT MODE".
* Translated message of "I" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INSERT MODE"));
}
break;
default:
/*
* TRANSLATION_NOTE
* "I" is a terse mode message corresponding to
* "INPUT MODE" and the previous "INSERT MODE".
* Translated message of "I" must be 1 character (not byte).
* Or, just leave it.
*/
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INPUT MODE"));
}
}
ixlatctl(1);
if ((vglobp && *vglobp == 0) || peekbr()) {
if (INS[128] == 0200) {
(void) beep();
if (!splitw)
ungetkey('u');
doomed = 0;
hold = oldhold;
return;
}
/*
* Unread input from INS.
* An escape will be generated at end of string.
* Hold off n^^2 type update on dumb terminals.
*/
vglobp = INS;
inscdcnt = INSCDCNT;
hold |= HOLDQIK;
} else if (vglobp == 0) {
/*
* Not a repeated command, get
* a new inserted text for repeat.
*/
INS[0] = 0;
INS[128] = 0;
INSCDCNT = 0;
}
/*
* For wrapmargin to hack away second space after a '.'
* when the first space caused a line break we keep
* track that this happened in gobblebl, which says
* to gobble up a blank silently.
*/
gobblebl = 0;
startsrcline = dot;
startsrccol = cursor - linebuf;
/*
* Text gathering loop.
* New text goes into genbuf starting at gcursor.
* cursor preserves place in linebuf where text will eventually go.
*/
if (*cursor == 0 || state == CRTOPEN)
hold |= HOLDROL;
for (;;) {
if (ch == 'r' && repcnt == 0)
escape = 0;
else {
ixlatctl(1);
/*
* When vgetline() returns, gcursor is
* pointing to '\0' and vgetline() has
* read an ESCAPE or NL.
*/
gcursor = vgetline(repcnt, gcursor, &escape, ch);
if (escape == '\n') {
gotNL = 1;
#ifdef XPG6
if (ch == 'r') {
/*
* XPG6 assertion 313 [count]r\n :
* Arrange to set cursor correctly.
*/
endsrccol = gcursor - genbuf - 1;
}
#endif /* XPG6 */
} else {
/*
* Upon escape, gcursor is pointing to '\0'
* terminating the string in genbuf.
*/
endsrccol = gcursor - genbuf - 1;
}
ixlatctl(0);
/*
* After an append, stick information
* about the ^D's and ^^D's and 0^D's in
* the repeated text buffer so repeated
* inserts of stuff indented with ^D as backtab's
* can work.
*/
if (HADUP)
addtext("^");
else if (HADZERO)
addtext("0");
if(!vglobp)
INSCDCNT = CDCNT;
while (CDCNT > 0) {
addtext("\004");
CDCNT--;
}
if (gobbled)
addtext(" ");
addtext(ogcursor);
}
repcnt = 0;
/*
* Smash the generated and preexisting indents together
* and generate one cleanly made out of tabs and spaces
* if we are using autoindent and this isn't 'r' command.
*/
if (!vaifirst && value(vi_AUTOINDENT)) {
i = fixindent(indent);
if (!HADUP)
indent = i;
gcursor = strend(genbuf);
}
/*
* Set cnt to 1 to avoid repeating the text on the same line.
* Do this for commands 'i', 'I', 'a', and 'A', if we're
* inserting anything with a newline for XPG6. Always do this
* for commands 'o' and 'O'.
*/
if ((imultlinecnt && gotNL) || omultlinecnt) {
cnt = 1;
}
/*
* Limit the repetition count based on maximum
* possible line length; do output implied
* by further count (> 1) and cons up the new line
* in linebuf.
*/
cnt = vmaxrep(ch, cnt);
/*
* cursor points to linebuf
* Copy remaining old text (cursor) in original
* line to after new text (gcursor + 1) in genbuf.
*/
CP(gcursor + 1, cursor);
/*
* For [count] r \n command, when replacing [count] chars
* with '\n', this loop replaces [count] chars with "".
*/
do {
/* cp new text (genbuf) into linebuf (cursor) */
CP(cursor, genbuf);
if (cnt > 1) {
int oldhold = hold;
Outchar = vinschar;
hold |= HOLDQIK;
viprintf("%s", genbuf);
hold = oldhold;
Outchar = vputchar;
}
/* point cursor after new text in linebuf */
cursor += gcursor - genbuf;
} while (--cnt > 0);
endim();
vUA2 = cursor;
/* add the remaining old text after the cursor */
if (escape != '\n')
CP(cursor, gcursor + 1);
/*
* If doomed characters remain, clobber them,
* and reopen the line to get the display exact.
* eg. c$ to change to end of line
*/
if (state != HARDOPEN) {
DEPTH(vcline) = 0;
savedoomed = doomed;
if (doomed > 0) {
int cind = cindent();
physdc(cind, cind + doomed);
doomed = 0;
}
if(MB_CUR_MAX > 1)
rewrite = _ON;
i = vreopen(LINE(vcline), lineDOT(), vcline);
if(MB_CUR_MAX > 1)
rewrite = _OFF;
#ifdef TRACE
if (trace)
fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed);
#endif
if (ch == 'R')
doomed = savedoomed;
}
/*
* Unless we are continuing on to another line
* (got a NL), break out of the for loop (got
* an ESCAPE).
*/
if (escape != '\n') {
vshowmode("");
break;
}
/*
* Set up for the new line.
* First save the current line, then construct a new
* first image for the continuation line consisting
* of any new autoindent plus the pushed ahead text.
*/
killU();
addtext(gobblebl ? " " : "\n");
/* save vutmp (for undo state) into temp file */
vsave();
cnt = 1;
if (value(vi_AUTOINDENT)) {
if (value(vi_LISP))
indent = lindent(dot + 1);
else
if (!HADUP && vaifirst)
indent = whitecnt(linebuf);
vaifirst = 0;
strcLIN(vpastwh(gcursor + 1));
gcursor = genindent(indent);
*gcursor = 0;
if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
gcursor = genbuf;
CP(gcursor, linebuf);
} else {
/*
* Put gcursor at start of genbuf to wipe
* out previous line in preparation for
* the next vgetline() loop.
*/
CP(genbuf, gcursor + 1);
gcursor = genbuf;
}
/*
* If we started out as a single line operation and are now
* turning into a multi-line change, then we had better yank
* out dot before it changes so that undo will work
* correctly later.
*/
if (FIXUNDO && vundkind == VCHNG) {
vremote(1, yank, 0);
undap1--;
}
/*
* Now do the append of the new line in the buffer,
* and update the display, ie: append genbuf to
* the file after dot. If slowopen
* we don't do very much.
*/
vdoappend(genbuf);
vundkind = VMANYINS;
vcline++;
if (state != VISUAL)
vshow(dot, NOLINE);
else {
i += LINE(vcline - 1);
vopen(dot, i);
if (value(vi_SLOWOPEN))
vscrap();
else
vsync1(LINE(vcline));
}
switch (ch) {
case 'r':
break;
case 'a':
if (value(vi_TERSE)) {
vshowmode(gettext("A"));
} else {
vshowmode(gettext("APPEND MODE"));
}
break;
case 's':
if (value(vi_TERSE)) {
vshowmode(gettext("S"));
} else {
vshowmode(gettext("SUBSTITUTE MODE"));
}
break;
case 'c':
if (value(vi_TERSE)) {
vshowmode(gettext("C"));
} else {
vshowmode(gettext("CHANGE MODE"));
}
break;
case 'R':
if (value(vi_TERSE)) {
vshowmode(gettext("R"));
} else {
vshowmode(gettext("REPLACE MODE"));
}
break;
case 'i':
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INSERT MODE"));
}
break;
case 'o':
if (value(vi_TERSE)) {
vshowmode(gettext("O"));
} else {
vshowmode(gettext("OPEN MODE"));
}
break;
default:
if (value(vi_TERSE)) {
vshowmode(gettext("I"));
} else {
vshowmode(gettext("INPUT MODE"));
}
}
strcLIN(gcursor);
/* zero genbuf */
*gcursor = 0;
cursor = linebuf;
vgotoCL(nqcolumn(cursor - 1, genbuf));
} /* end for (;;) loop in vappend() */
if (imultlinecnt && gotNL) {
imultlinerep(savecnt, startsrcline, startsrccol, endsrccol);
} else if (omultlinecnt) {
omultlinerep(savecnt, startsrcline, endsrccol);
#ifdef XPG6
} else if (savecnt > 1 && ch == 'r' && gotNL) {
/*
* XPG6 assertion 313 & 254 : Position cursor for [count]r\n
* then insert [count -1] newlines.
*/
endsrccol = gcursor - genbuf - 1;
rmultlinerep(savecnt, endsrccol);
#endif /* XPG6 */
}
/*
* All done with insertion, position the cursor
* and sync the screen.
*/
hold = oldhold;
if ((imultlinecnt && gotNL) || omultlinecnt) {
fixdisplay();
#ifdef XPG6
} else if (savecnt > 1 && ch == 'r' && gotNL) {
fixdisplay();
/*
* XPG6 assertion 313 & 254 [count]r\n : Set flag to call
* fixdisplay() after operate() has finished. To be sure that
* the text (after the last \n followed by an indent) is always
* displayed, fixdisplay() is called right before getting
* the next command.
*/
redisplay = 1;
#endif /* XPG6 */
} else if (cursor > linebuf) {
cursor = lastchr(linebuf, cursor);
#ifdef XPG6
/*
* XPG6 assertion 313 & 254 [count]r\n :
* For 'r' command, when the replacement char causes new
* lines to be created, point cursor to first non-blank.
* The old code, ie: cursor = lastchr(linebuf, cursor);
* set cursor to the blank before the first non-blank
* for r\n
*/
if (ch == 'r' && gotNL && isblank((int)*cursor))
++cursor;
#endif /* XPG6 */
}
if (state != HARDOPEN)
vsyncCL();
else if (cursor > linebuf)
back1();
doomed = 0;
wcursor = cursor;
(void) vmove();
}
