NetBSD/usr.bin/vi/sex/sex_get.c

515 lines
13 KiB
C

/*-
* Copyright (c) 1992, 1993, 1994
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef lint
static char sccsid[] = "@(#)sex_get.c 8.39 (Berkeley) 8/17/94";
#endif /* not lint */
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/time.h>
#include <bitstring.h>
#include <ctype.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include "compat.h"
#include <db.h>
#include <regex.h>
#include "vi.h"
#include "excmd.h"
#include "../vi/vcmd.h"
#include "sex_screen.h"
/*
* !!!
* The ex input didn't have escape characters like ^V. The only special
* character was the backslash character, and that only when it preceded
* a newline as part of a substitution replacement pattern. For example,
* the command input ":a\<cr>" failed immediately with an error, as the
* <cr> wasn't part of a substitution replacement pattern. This implies
* a frightening integration of the editor and the RE engine. There's no
* way we're going to reproduce those semantics. So, if backslashes are
* special, this code inserts the backslash and the next character into the
* string, without regard for the character or the command being entered.
* Since "\<cr>" was illegal historically (except for the one special case),
* and the command will fail eventually, historical scripts shouldn't break
* (presuming they didn't depend on the failure mode itself or the characters
* remaining when failure occurred.
*/
static void txt_display __P((SCR *, TEXT *, size_t, size_t *));
static int txt_outdent __P((SCR *, TEXT *));
#define ERASECH { \
for (cnt = tp->wd[tp->len]; cnt-- > 0; --col) \
(void)printf("\b \b"); \
}
/*
* sex_get --
* Get lines from the terminal for ex.
*/
enum input
sex_get(sp, ep, tiqh, prompt, flags)
SCR *sp;
EXF *ep;
TEXTH *tiqh;
ARG_CHAR_T prompt;
u_int flags;
{
/* State of the "[^0]^D" sequences. */
enum { C_NOTSET, C_CARATSET, C_NOCHANGE, C_ZEROSET } carat_st;
TEXT *ntp, *tp, ait; /* Input and autoindent text structures. */
CH ikey; /* Input character. */
size_t col; /* 0-N: screen column. */
size_t cnt;
int rval, istty;
/*
* !!!
* Most of the special capabilities (like autoindent, erase,
* etc.) are turned off if ex isn't talking to a terminal.
*/
istty = F_ISSET(sp->gp, G_STDIN_TTY);
/*
* Get a TEXT structure with some initial buffer space, reusing
* the last one if it's big enough. (All TEXT bookkeeping fields
* default to 0 -- text_init() handles this.)
*/
if (tiqh->cqh_first != (void *)tiqh) {
tp = tiqh->cqh_first;
if (tp->q.cqe_next != (void *)tiqh || tp->lb_len < 32) {
text_lfree(tiqh);
goto newtp;
}
tp->len = 0;
} else {
newtp: if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
return (INP_ERR);
CIRCLEQ_INSERT_HEAD(tiqh, tp, q);
}
if (istty) {
/* Display the prompt. */
if (LF_ISSET(TXT_PROMPT)) {
col = KEY_LEN(sp, prompt);
(void)printf("%s", KEY_NAME(sp, prompt));
}
/* Initialize autoindent value and print it out. */
if (LF_ISSET(TXT_AUTOINDENT)) {
if (txt_auto(sp, ep, sp->lno, NULL, 0, tp))
return (INP_ERR);
BINC_GOTO(sp, tp->wd, tp->wd_len, tp->len + 1);
for (cnt = 0; cnt < tp->ai; ++cnt)
txt_display(sp, tp, cnt, &col);
}
} else {
col = 0;
/* Turn off autoindent here, less special casing below. */
LF_CLR(TXT_AUTOINDENT);
}
for (carat_st = C_NOTSET;;) {
if (istty)
(void)fflush(stdout);
/*
* !!!
* Historically, ex never mapped commands or keys.
*/
if (rval = term_key(sp, &ikey, 0))
return (rval);
if (INTERRUPTED(sp))
return (INP_INTR);
BINC_GOTO(sp, tp->lb, tp->lb_len, tp->len + 1);
BINC_GOTO(sp, tp->wd, tp->wd_len, tp->len + 1);
switch (ikey.value) {
case K_CR:
case K_NL:
/* '\' can escape <carriage-return>/<newline>. */
if (LF_ISSET(TXT_BACKSLASH) &&
tp->len != 0 && tp->lb[tp->len - 1] == '\\')
goto ins_ch;
/* Echo the newline if requested. */
if (istty && LF_ISSET(TXT_NLECHO)) {
(void)putc('\r', stdout);
(void)putc('\n', stdout);
(void)fflush(stdout);
}
/*
* CR returns from the ex command line, interrupt
* always returns.
*/
if (LF_ISSET(TXT_CR)) {
/* Terminate with a nul, needed by filter. */
tp->lb[tp->len] = '\0';
return (INP_OK);
}
/* '.' terminates ex input modes. */
if (LF_ISSET(TXT_DOTTERM) &&
tp->len == tp->ai + 1 &&
tp->lb[tp->len - 1] == '.') {
/* Release the current TEXT. */
ntp = tp->q.cqe_prev;
CIRCLEQ_REMOVE(tiqh, tp, q);
text_free(tp);
tp = ntp;
return (INP_OK);
}
/*
* If we echoed the newline, display any accumulated
* error messages.
*/
if (LF_ISSET(TXT_NLECHO) && sex_refresh(sp, ep))
return (INP_ERR);
/* Set up bookkeeping for the new line. */
if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
return (INP_ERR);
ntp->lno = tp->lno + 1;
/*
* Reset the autoindent line value. 0^D keeps the ai
* line from changing, ^D changes the level, even if
* there are no characters in the old line. Note,
* if using the current tp structure, use the cursor
* as the length, the user may have erased autoindent
* characters.
*/
col = 0;
if (LF_ISSET(TXT_AUTOINDENT)) {
if (carat_st == C_NOCHANGE) {
if (txt_auto(sp, ep,
OOBLNO, &ait, ait.ai, ntp))
return (INP_ERR);
FREE_SPACE(sp, ait.lb, ait.lb_len);
} else
if (txt_auto(sp, ep,
OOBLNO, tp, tp->len, ntp))
return (INP_ERR);
carat_st = C_NOTSET;
if (ntp->ai) {
BINC_GOTO(sp,
ntp->wd, ntp->wd_len, ntp->len + 1);
for (cnt = 0; cnt < ntp->ai; ++cnt)
txt_display(sp, ntp, cnt, &col);
}
}
/*
* Swap old and new TEXT's, and insert the new TEXT
* into the queue.
*/
tp = ntp;
CIRCLEQ_INSERT_TAIL(tiqh, tp, q);
break;
case K_CARAT: /* Delete autoindent chars. */
if (LF_ISSET(TXT_AUTOINDENT) && tp->len <= tp->ai)
carat_st = C_CARATSET;
goto ins_ch;
case K_ZERO: /* Delete autoindent chars. */
if (LF_ISSET(TXT_AUTOINDENT) && tp->len <= tp->ai)
carat_st = C_ZEROSET;
goto ins_ch;
case K_CNTRLD: /* Delete autoindent char. */
/*
* !!!
* Historically, the ^D command took (but then ignored)
* a count. For simplicity, we don't return it unless
* it's the first character entered. The check for len
* equal to 0 is okay, TXT_AUTOINDENT won't be set.
*/
if (LF_ISSET(TXT_CNTRLD)) {
for (cnt = 0; cnt < tp->len; ++cnt)
if (!isblank(tp->lb[cnt]))
break;
if (cnt == tp->len) {
tp->len = 1;
tp->lb[0] = '\004';
tp->lb[1] = '\0';
return (INP_OK);
}
}
/*
* If in the first column or no characters to erase,
* ignore the ^D (this matches historic practice). If
* not doing autoindent or already inserted non-ai
* characters, it's a literal. The latter test is done
* in the switch, as the CARAT forms are N + 1, not N.
*/
if (!LF_ISSET(TXT_AUTOINDENT))
goto ins_ch;
if (tp->len == 0)
break;
switch (carat_st) {
case C_CARATSET: /* ^^D */
if (tp->len > tp->ai + 1)
goto ins_ch;
/* Save the ai string for later. */
ait.lb = NULL;
ait.lb_len = 0;
BINC_GOTO(sp, ait.lb, ait.lb_len, tp->ai);
memmove(ait.lb, tp->lb, tp->ai);
ait.ai = ait.len = tp->ai;
carat_st = C_NOCHANGE;
goto leftmargin;
case C_ZEROSET: /* 0^D */
if (tp->len > tp->ai + 1)
goto ins_ch;
carat_st = C_NOTSET;
leftmargin: (void)printf("\b \r");
tp->ai = tp->len = 0;
break;
case C_NOTSET: /* ^D */
if (tp->len > tp->ai)
goto ins_ch;
if (txt_outdent(sp, tp))
return (INP_ERR);
break;
default:
abort();
}
break;
case K_VERASE:
if (!istty)
goto ins_ch;
if (tp->len) {
--tp->len;
if (tp->lb[tp->len] == '\n' ||
tp->lb[tp->len] == '\r')
goto repaint;
ERASECH;
}
break;
case K_VWERASE:
if (!istty)
goto ins_ch;
/* Move to the last non-space character. */
while (tp->len) {
--tp->len;
if (tp->lb[tp->len] == '\n' ||
tp->lb[tp->len] == '\r')
goto repaint;
if (!isblank(tp->lb[tp->len])) {
++tp->len;
break;
} else
ERASECH;
}
/* Move to the last space character. */
while (tp->len) {
--tp->len;
if (tp->lb[tp->len] == '\n' ||
tp->lb[tp->len] == '\r')
goto repaint;
if (isblank(tp->lb[tp->len])) {
++tp->len;
break;
} else
ERASECH;
}
break;
case K_VKILL:
if (!istty)
goto ins_ch;
while (tp->len) {
--tp->len;
if (tp->lb[tp->len] == '\n' ||
tp->lb[tp->len] == '\r') {
tp->len = 0;
goto repaint;
}
ERASECH;
}
break;
/*
* XXX
* Historic practice is that ^Z suspended command mode, and
* that it was unaffected by the autowrite option. ^Z ended
* insert mode, retaining all but the current line of input,
* which was discarded. When ex was foregrounded, it was in
* command mode. I don't want to discard input because a user
* tried to enter a ^Z, and I'd like to be consistent with vi.
* So, nex matches vi's historic practice, and doesn't permit
* ^Z in input mode.
*/
case K_CNTRLZ:
if (!istty || !LF_ISSET(TXT_EXSUSPEND))
goto ins_ch;
sex_suspend(sp);
goto repaint;
case K_CNTRLR:
if (!istty)
goto ins_ch;
repaint: if (LF_ISSET(TXT_PROMPT)) {
col = KEY_LEN(sp, prompt);
(void)printf("\r%s", KEY_NAME(sp, prompt));
} else {
col = 0;
(void)putc('\r', stdout);
}
for (cnt = 0; cnt < tp->len; ++cnt)
txt_display(sp, tp, cnt, &col);
break;
default:
/*
* See the TXT_BEAUTIFY comment in vi/v_ntext.c.
*
* Silently eliminate any iscntrl() character that
* wasn't already handled specially, except for <tab>
* and <ff>.
*/
ins_ch: if (LF_ISSET(TXT_BEAUTIFY) && iscntrl(ikey.ch) &&
ikey.value != K_FORMFEED && ikey.value != K_TAB)
break;
tp->lb[tp->len] = ikey.ch;
if (istty)
txt_display(sp, tp, tp->len, &col);
++tp->len;
break;
}
}
/* NOTREACHED */
binc_err:
return (INP_ERR);
}
/*
* txt_display --
* Display the character.
*/
static void
txt_display(sp, tp, off, colp)
SCR *sp;
TEXT *tp;
size_t off, *colp;
{
CHAR_T ch;
size_t width;
switch (ch = tp->lb[off]) {
case '\t':
*colp += tp->wd[off] = width =
O_VAL(sp, O_TABSTOP) - *colp % O_VAL(sp, O_TABSTOP);
while (width--)
putc(' ', stdout);
break;
case '\n':
case '\r':
(void)putc('\r', stdout);
(void)putc('\n', stdout);
break;
default:
*colp += tp->wd[off] = KEY_LEN(sp, ch);
(void)printf("%s", KEY_NAME(sp, ch));
}
}
/*
* txt_outdent --
* Handle ^D outdents.
*
* Ex version of vi/v_ntext.c:txt_outdent(). See that code for the
* usual ranting and raving.
*/
static int
txt_outdent(sp, tp)
SCR *sp;
TEXT *tp;
{
u_long sw, ts;
size_t cno, cnt, off, scno, spaces;
ts = O_VAL(sp, O_TABSTOP);
sw = O_VAL(sp, O_SHIFTWIDTH);
/* Get the current screen column. */
for (off = scno = 0; off < tp->len; ++off)
if (tp->lb[off] == '\t')
scno += STOP_OFF(scno, ts);
else
++scno;
/* Get the previous shiftwidth column. */
for (cno = scno; --scno % sw != 0;);
/* Decrement characters until less than or equal to that slot. */
for (; cno > scno; --tp->ai) {
for (cnt = tp->wd[--tp->len]; cnt-- > 0;)
(void)printf("\b \b");
if (tp->lb[--off] == '\t')
cno -= STOP_OFF(cno, ts);
else
--cno;
}
/* Spaces needed to get to the target. */
spaces = scno - cno;
/* Maybe just a delete. */
if (spaces == 0)
return (0);
/* Make sure there's enough room. */
BINC_RET(sp, tp->lb, tp->lb_len, tp->len + spaces);
/* Maybe that was enough. */
if (spaces == 0)
return (0);
/* Add new space characters. */
for (; spaces--; ++tp->ai)
tp->lb[tp->len++] = ' ';
return (0);
}