/* Copyright (c) 1979 Regents of the University of California */

#include "ex.h"

#include "ex_tty.h"

#include "ex_vis.h"

/*

* Low level routines for operations sequences,

* and mostly, insert mode (and a subroutine

* to read an input line, including in the echo area.)

*/

extern char *vUA1, *vUA2;

extern char *vUD1, *vUD2;

static int vgetsplit(void);

static int vmaxrep(int, int);

/*

* Obleeperate characters in hardcopy

* open with \'s.

*/

void

bleep(int i, char *cp)

{

i -= column(cp);

do

ex_putchar('\\' | QUOTE);

while (--i >= 0);

rubble = 1;

}

/*

* Common code for middle part of delete

* and change operating on parts of lines.

*/

int

vdcMID(void)

{

register char *cp;

squish();

setLAST();

vundkind = VCHNG, CP(vutmp, linebuf);

if (wcursor < cursor)

cp = wcursor, wcursor = cursor, cursor = cp;

vUD1 = vUA1 = vUA2 = cursor; vUD2 = wcursor;

return (column(wcursor - 1));

}

/*

* Take text from linebuf and stick it

* in the VBSIZE buffer BUF. Used to save

* deleted text of part of line.

*/

void

takeout(char *BUF)

{

register char *cp;

if (wcursor < linebuf)

wcursor = linebuf;

if (cursor == wcursor) {

beep();

return;

}

if (wcursor < cursor) {

cp = wcursor;

wcursor = cursor;

cursor = cp;

}

setBUF(BUF);

if ((BUF[0] & (OVERBUF|TRIM)) == OVERBUF)

beep();

}

/*

* Are we at the end of the printed representation of the

* line? Used internally in hardcopy open.

*/

int

ateopr(void)

{

register int i, c;

register char *cp = vtube[destline] + destcol;

for (i = WCOLS - destcol; i > 0; i--) {

c = *cp++;

if (c == 0)

return (1);

if (c != ' ' && (c & QUOTE) == 0)

return (0);

}

return (1);

}

/*

* Append.

*

* This routine handles the top level append, doing work

* as each new line comes in, and arranging repeatability.

* It also handles append with repeat counts, and calculation

* of autoindents for new lines.

*/

bool vaifirst;

bool gobbled;

char *ogcursor;

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();

}

/*

* Subroutine for vgetline to back up a single character position,

* backwards around end of lines (vgoto can't hack columns which are

* less than 0 in general).

*/

void

back1(void)

{

vgoto(destline - 1, WCOLS + destcol - 1);

}

/*

* Get a line into genbuf after gcursor.

* Cnt limits the number of input characters

* accepted and is used for handling the replace

* single character command. Aescaped is the location

* where we stick a termination indicator (whether we

* ended with an ESCAPE or a newline/return.

*

* We do erase-kill type processing here and also

* are careful about the way we do this so that it is

* repeatable. (I.e. so that your kill doesn't happen,

* when you repeat an insert if it was escaped with \ the

* first time you did it.

*/

char *

vgetline(int cnt, char *gcursor, bool *aescaped)

{

register int c, ch;

register char *cp;

int x, y, iwhite;

char *iglobp;

void (*OO)() = Outchar;

/*

* Clear the output state and counters

* for autoindent backwards motion (counts of ^D, etc.)

* Remember how much white space at beginning of line so

* as not to allow backspace over autoindent.

*/

*aescaped = 0;

ogcursor = gcursor;

flusho();

CDCNT = 0;

HADUP = 0;

HADZERO = 0;

gobbled = 0;

iwhite = whitecnt(genbuf);

iglobp = vglobp;

/*

* Carefully avoid using vinschar in the echo area.

*/

if (splitw)

Outchar = vputchar;

else {

Outchar = vinschar;

vprepins();

}

for (;;) {

if (gobblebl)

gobblebl--;

if (cnt != 0) {

cnt--;

if (cnt == 0)

goto vadone;

}

ch = c = getkey() & (QUOTE|TRIM);

if (!iglobp) {

/*

* Erase-kill type processing.

* Only happens if we were not reading

* from untyped input when we started.

* Map users erase to ^H, kill to -1 for switch.

*/

if (c == tty.c_cc[VERASE])

c = CTRL('h');

else if (c == tty.c_cc[VKILL])

c = -1;

switch (c) {

/*

* ^? Interrupt drops you back to visual

* command mode with an unread interrupt

* still in the input buffer.

*

* ^\ Quit does the same as interrupt.

* If you are a ex command rather than

* a vi command this will drop you

* back to command mode for sure.

*/

case ATTN:

case QUIT:

ungetkey(c);

goto vadone;

/*

* ^H Backs up a character in the input.

*

* BUG: Can't back around line boundaries.

* This is hard because stuff has

* already been saved for repeat.

*/

case CTRL('h'):

bakchar:

cp = gcursor - 1;

if (cp < ogcursor) {

beep();

continue;

}

goto vbackup;

/*

* ^W Back up a white/non-white word.

*/

case CTRL('w'):

wdkind = 1;

for (cp = gcursor; cp > ogcursor && isspace((int)cp[-1]); cp--)

continue;

for (c = wordch(cp - 1); cp > ogcursor && wordof(c, cp - 1); cp--)

continue;

goto vbackup;

/*

* users kill Kill input on this line, back to

* the autoindent.

*/

case -1:

cp = ogcursor;

vbackup:

if (cp == gcursor) {

beep();

continue;

}

endim();

*cp = 0;

c = cindent();

vgotoCL(qcolumn(cursor - 1, genbuf));

if (doomed >= 0)

doomed += c - cindent();

gcursor = cp;

continue;

/*

* \ Followed by erase or kill

* maps to just the erase or kill.

*/

case '\\':

x = destcol, y = destline;

ex_putchar('\\');

vcsync();

c = getkey();

if (c == tty.c_cc[VERASE]

|| c == tty.c_cc[VKILL]) {

vgoto(y, x);

if (doomed >= 0)

doomed++;

goto def;

}

ungetkey(c), c = '\\';

goto noput;

/*

* ^Q Super quote following character

* Only ^@ is verboten (trapped at

* a lower level) and \n forces a line

* split so doesn't really go in.

*

* ^V Synonym for ^Q

*/

case CTRL('q'):

case CTRL('v'):

x = destcol, y = destline;

ex_putchar('^');

vgoto(y, x);

c = getkey();

if (c != NL) {

if (doomed >= 0)

doomed++;

goto def;

}

break;

}

}

/*

* If we get a blank not in the echo area

* consider splitting the window in the wrapmargin.

*/

if (c == ' ' && !splitw) {

if (gobblebl) {

gobbled = 1;

continue;

}

if (value(WRAPMARGIN) && outcol >= WCOLS - value(WRAPMARGIN)) {

c = NL;

gobblebl = 2;

}

}

switch (c) {

/*

* ^M Except in repeat maps to \n.

*/

case CR:

if (vglobp)

goto def;

c = '\n';

/* presto chango ... */

/*

* \n Start new line.

*/

case NL:

*aescaped = c;

goto vadone;

/*

* escape End insert unless repeat and more to repeat.

*/

case ESCAPE:

if (vglobp && *vglobp)

goto def;

goto vadone;

/*

* ^D Backtab.

* ^T Software forward tab.

*

* Unless in repeat where this means these

* were superquoted in.

*/

case CTRL('d'):

case CTRL('t'):

if (vglobp)

goto def;

/* fall into ... */

/*

* ^D|QUOTE Is a backtab (in a repeated command).

*/

case CTRL('d') | QUOTE:

*gcursor = 0;

cp = vpastwh(genbuf);

c = whitecnt(genbuf);

if (ch == CTRL('t')) {

/*

* ^t just generates new indent replacing

* current white space rounded up to soft

* tab stop increment.

*/

if (cp != gcursor)

/*

* BUG: Don't hack ^T except

* right after initial

* white space.

*/

continue;

cp = genindent(iwhite = backtab(c + value(SHIFTWIDTH) + 1));

ogcursor = cp;

goto vbackup;

}

/*

* ^D works only if we are at the (end of) the

* generated autoindent. We count the ^D for repeat

* purposes.

*/

if (c == iwhite && c != 0) {

if (cp == gcursor) {

iwhite = backtab(c);

CDCNT++;

ogcursor = cp = genindent(iwhite);

goto vbackup;

} else if (&cp[1] == gcursor &&

(*cp == '^' || *cp == '0')) {

/*

* ^^D moves to margin, then back

* to current indent on next line.

*

* 0^D moves to margin and then

* stays there.

*/

HADZERO = *cp == '0';

ogcursor = cp = genbuf;

HADUP = 1 - HADZERO;

CDCNT = 1;

endim();

back1();

vputc(' ');

goto vbackup;

}

}

if (vglobp && vglobp - iglobp >= 2 &&

(vglobp[-2] == '^' || vglobp[-2] == '0')

&& gcursor == ogcursor + 1)

goto bakchar;

continue;

default:

/*

* Possibly discard control inputs.

*/

if (!vglobp && junk(c)) {

beep();

continue;

}

def:

ex_putchar(c);

noput:

if (gcursor > &genbuf[LBSIZE - 2])

error("Line too long");

*gcursor++ = c & TRIM;

vcsync();

#ifdef LISP

if (value(SHOWMATCH) && !iglobp)

if (c == ')' || c == '}')

lsmatch(gcursor);

#endif

continue;

}

}

vadone:

*gcursor = 0;

Outchar = OO;

endim();

return (gcursor);

}

char *vsplitpt;

/*

* Append the line in buffer at lp

* to the buffer after dot.

*/

void

vdoappend(char *lp)

{

register int oing = inglobal;

vsplitpt = lp;

inglobal = 1;

ignore(append(vgetsplit, dot));

inglobal = oing;

}

/*

* Subroutine for vdoappend to pass to append.

*/

static int

vgetsplit(void)

{

if (vsplitpt == 0)

return (EOF);

strcLIN(vsplitpt);

vsplitpt = 0;

return (0);

}

/*

* Vmaxrep determines the maximum repetitition factor

* allowed that will yield total line length less than

* 512 characters and also does hacks for the R command.

*/

static int

vmaxrep(int ch, int cnt)

{

register int len, replen;

if (cnt > LBSIZE - 2)

cnt = LBSIZE - 2;

replen = strlen(genbuf);

if (ch == 'R') {

len = strlen(cursor);

if (replen < len)

len = replen;

CP(cursor, cursor + len);

vUD2 += len;

}

len = strlen(linebuf);

if (len + cnt * replen <= LBSIZE - 2)

return (cnt);

cnt = (LBSIZE - 2 - len) / replen;

if (cnt == 0) {

vsave();

error("Line too long");

}

return (cnt);

}