/*
* mark_get --
* Get the location referenced by a mark.
*
* PUBLIC: int mark_get __P((SCR *, ARG_CHAR_T, MARK *, mtype_t));
*/
int
mark_get(SCR *sp, ARG_CHAR_T key, MARK *mp, mtype_t mtype)
{
LMARK *lmp;
if (key == ABSMARK2)
key = ABSMARK1;
lmp = mark_find(sp, key);
if (lmp == NULL || (ARG_CHAR_T)lmp->name != key) {
msgq(sp, mtype, "017|Mark %s: not set", KEY_NAME(sp, key));
return (1);
}
if (F_ISSET(lmp, MARK_DELETED)) {
msgq(sp, mtype,
"018|Mark %s: the line was deleted", KEY_NAME(sp, key));
return (1);
}
/*
* !!!
* The absolute mark is initialized to lno 1/cno 0, and historically
* you could use it in an empty file. Make such a mark always work.
*/
if ((lmp->lno != 1 || lmp->cno != 0) && !db_exist(sp, lmp->lno)) {
msgq(sp, mtype,
"019|Mark %s: cursor position no longer exists",
KEY_NAME(sp, key));
return (1);
}
mp->lno = lmp->lno;
mp->cno = lmp->cno;
return (0);
}
/*
* ex_map -- :map[!] [input] [replacement]
* Map a key/string or display mapped keys.
*
* Historical note:
* Historic vi maps were fairly bizarre, and likely to differ in
* very subtle and strange ways from this implementation. Two
* things worth noting are that vi would often hang or drop core
* if the map was strange enough (ex: map X "xy$@x^V), or, simply
* not work. One trick worth remembering is that if you put a
* mark at the start of the map, e.g. map X mx"xy ...), or if you
* put the map in a .exrc file, things would often work much better.
* No clue why.
*
* PUBLIC: int ex_map __P((SCR *, EXCMD *));
*/
int
ex_map(SCR *sp, EXCMD *cmdp)
{
seq_t stype;
CHAR_T *input, *p;
stype = FL_ISSET(cmdp->iflags, E_C_FORCE) ? SEQ_INPUT : SEQ_COMMAND;
switch (cmdp->argc) {
case 0:
if (seq_dump(sp, stype, 1) == 0)
msgq(sp, M_INFO, stype == SEQ_INPUT ?
"132|No input map entries" :
"133|No command map entries");
return (0);
case 2:
input = cmdp->argv[0]->bp;
break;
default:
abort();
}
/*
* If the mapped string is #[0-9]* (and wasn't quoted) then store the
* function key mapping. If the screen specific routine has been set,
* call it as well. Note, the SEQ_FUNCMAP type is persistent across
* screen types, maybe the next screen type will get it right.
*/
if (input[0] == '#' && ISDIGIT((UCHAR_T)input[1])) {
for (p = input + 2; ISDIGIT((UCHAR_T)*p); ++p);
if (p[0] != '\0')
goto nofunc;
if (seq_set(sp, NULL, 0, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len, stype,
SEQ_FUNCMAP | SEQ_USERDEF))
return (1);
return (sp->gp->scr_fmap == NULL ? 0 :
sp->gp->scr_fmap(sp, stype, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len));
}
/* Some single keys may not be remapped in command mode. */
nofunc: if (stype == SEQ_COMMAND && input[1] == '\0')
switch (KEY_VAL(sp, input[0])) {
case K_COLON:
case K_ESCAPE:
case K_NL:
msgq(sp, M_ERR,
"134|The %s character may not be remapped",
KEY_NAME(sp, input[0]));
return (1);
default:
break;
}
return (seq_set(sp, NULL, 0, input, cmdp->argv[0]->len,
cmdp->argv[1]->bp, cmdp->argv[1]->len, stype, SEQ_USERDEF));
}
/*
* ex_prchars --
* Local routine to dump characters to the screen.
*/
static int
ex_prchars(SCR *sp, const CHAR_T *p, size_t *colp, size_t len,
u_int flags, int repeatc)
{
CHAR_T ch;
char *kp;
GS *gp;
size_t col, tlen, ts;
if (O_ISSET(sp, O_LIST))
LF_SET(E_C_LIST);
gp = sp->gp;
ts = O_VAL(sp, O_TABSTOP);
for (col = *colp; len--;)
if ((ch = *p++) == L('\t') && !LF_ISSET(E_C_LIST))
for (tlen = ts - col % ts;
col < sp->cols && tlen--; ++col) {
(void)ex_printf(sp,
"%c", repeatc ? repeatc : ' ');
if (INTERRUPTED(sp))
goto intr;
}
else {
kp = KEY_NAME(sp, ch);
tlen = KEY_COL(sp, ch);
/*
* Start a new line if the last character does not fit
* into the current line. The implicit new lines are
* not interruptible.
*/
if (col + tlen > sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
col += tlen;
if (!repeatc) {
(void)ex_puts(sp, kp);
if (INTERRUPTED(sp))
goto intr;
} else while (tlen--) {
(void)ex_printf(sp, "%c", repeatc);
if (INTERRUPTED(sp))
goto intr;
}
if (col == sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
}
intr: *colp = col;
return (0);
}
/*
* ex_viusage -- :viusage [key]
* Display vi usage strings.
*
* PUBLIC: int ex_viusage __P((SCR *, EXCMD *));
*/
int
ex_viusage(SCR *sp, EXCMD *cmdp)
{
VIKEYS const *kp;
int key;
switch (cmdp->argc) {
case 1:
if (cmdp->argv[0]->len != 1) {
ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
return (1);
}
key = cmdp->argv[0]->bp[0];
if (key > MAXVIKEY)
goto nokey;
/* Special case: '[' and ']' commands. */
if ((key == '[' || key == ']') && cmdp->argv[0]->bp[1] != key)
goto nokey;
/* Special case: ~ command. */
if (key == '~' && O_ISSET(sp, O_TILDEOP))
kp = &tmotion;
else
kp = &vikeys[key];
if (kp->usage == NULL)
nokey: (void)ex_printf(sp,
"The %s key has no current meaning\n",
KEY_NAME(sp, key));
else
(void)ex_printf(sp,
" Key:%s%s\nUsage: %s\n",
isblank((unsigned char)*kp->help) ? "" : " ", kp->help, kp->usage);
break;
case 0:
for (key = 0; key <= MAXVIKEY && !INTERRUPTED(sp); ++key) {
/* Special case: ~ command. */
if (key == '~' && O_ISSET(sp, O_TILDEOP))
kp = &tmotion;
else
kp = &vikeys[key];
if (kp->help != NULL)
(void)ex_printf(sp, "%s\n", kp->help);
}
break;
default:
abort();
}
return (0);
}
/*
* db --
* Display a buffer.
*/
static void
db(SCR *sp, CB *cbp, const char *np)
{
CHAR_T *p;
GS *gp;
TEXT *tp;
size_t len;
const unsigned char *name = (const void *)np;
gp = sp->gp;
(void)ex_printf(sp, "********** %s%s\n",
name == NULL ? KEY_NAME(sp, cbp->name) : name,
F_ISSET(cbp, CB_LMODE) ? " (line mode)" : " (character mode)");
for (tp = cbp->textq.cqh_first;
tp != (void *)&cbp->textq; tp = tp->q.cqe_next) {
for (len = tp->len, p = tp->lb; len--; ++p) {
(void)ex_puts(sp, (char *)KEY_NAME(sp, *p));
if (INTERRUPTED(sp))
return;
}
(void)ex_puts(sp, "\n");
}
}
/*
* ex_prchars --
* Local routine to dump characters to the screen.
*/
static int
ex_prchars(SCR *sp, const CHAR_T *p, size_t *colp, size_t len,
u_int flags, int repeatc)
{
CHAR_T ch;
const char *kp;
size_t col, tlen, ts;
if (O_ISSET(sp, O_LIST))
LF_SET(E_C_LIST);
ts = O_VAL(sp, O_TABSTOP);
for (col = *colp; len--;)
if ((ch = *p++) == L('\t') && !LF_ISSET(E_C_LIST))
for (tlen = ts - col % ts;
col < sp->cols && tlen--; ++col) {
(void)ex_printf(sp,
"%c", repeatc ? repeatc : ' ');
if (INTERRUPTED(sp))
goto intr;
}
else {
/* XXXX */
if (INTISWIDE(ch)) {
CHAR_T str[2] = {0, 0};
str[0] = ch;
INT2CHAR(sp, str, 2, kp, tlen);
} else {
kp = (char *)KEY_NAME(sp, ch);
tlen = KEY_LEN(sp, ch);
}
if (!repeatc && col + tlen < sp->cols) {
(void)ex_puts(sp, kp);
col += tlen;
} else
for (; tlen--; ++kp, ++col) {
if (col == sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
(void)ex_printf(sp,
"%c", repeatc ? repeatc : *kp);
if (INTERRUPTED(sp))
goto intr;
}
}
intr: *colp = col;
return (0);
}
/*
* msg_print --
* Return a printable version of a string, in allocated memory.
*
* PUBLIC: char *msg_print(SCR *, const char *, int *);
*/
char *
msg_print(
SCR *sp,
const char *s,
int *needfree)
{
size_t blen, nlen;
char *bp, *ep, *p, *t;
CHAR_T *wp, *cp;
size_t wlen;
*needfree = 0;
/* XXX Not good for debugging ex_read & ex_filter.*/
CHAR2INT5(sp, EXP(sp)->ibcw, (char *)s, strlen(s) + 1, wp, wlen);
for (cp = wp; *cp != '\0'; ++cp)
if (!ISPRINT(*cp))
break;
if (*cp == '\0')
return ((char *)s); /* SAFE: needfree set to 0. */
nlen = 0;
if (0) {
retry: if (sp == NULL)
free(bp);
else
FREE_SPACE(sp, bp, blen);
*needfree = 0;
}
nlen += 256;
if (sp == NULL) {
if ((bp = malloc(nlen)) == NULL)
goto alloc_err;
} else
GET_SPACE_GOTOC(sp, bp, blen, nlen);
if (0) {
alloc_err: return ("");
}
*needfree = 1;
for (p = bp, ep = (bp + blen) - 1; *wp != '\0' && p < ep; ++wp)
for (t = KEY_NAME(sp, *wp); *t != '\0' && p < ep; *p++ = *t++);
if (p == ep)
goto retry;
*p = '\0';
return (bp);
}
/*
* msg_print --
* Return a printable version of a string, in allocated memory.
*
* PUBLIC: char *msg_print __P((SCR *, const char *, int *));
*/
char *
msg_print(SCR *sp, const char *s, int *needfree)
{
size_t blen, nlen;
const char *cp;
char *bp, *ep, *p;
unsigned char *t;
*needfree = 0;
for (cp = s; *cp != '\0'; ++cp)
if (!isprint((unsigned char)*cp))
break;
if (*cp == '\0')
return ((char *)__UNCONST(s)); /* SAFE: needfree set to 0. */
nlen = 0;
if (0) {
retry: if (sp == NULL)
free(bp);
else
FREE_SPACE(sp, bp, blen);
*needfree = 0;
}
nlen += 256;
if (sp == NULL) {
if ((bp = malloc(nlen)) == NULL)
goto alloc_err;
} else
GET_SPACE_GOTOC(sp, bp, blen, nlen);
if (0) {
alloc_err: return __UNCONST("");
}
*needfree = 1;
for (p = bp, ep = (bp + blen) - 1, cp = s; *cp != '\0' && p < ep; ++cp)
for (t = KEY_NAME(sp, *cp); *t != '\0' && p < ep; *p++ = *t++);
if (p == ep)
goto retry;
*p = '\0';
return (bp);
}
static void
notfound(SCR *sp, ARG_CHAR_T ch)
{
msgq(sp, M_BERR, "179|%s not found", KEY_NAME(sp, ch));
}
/*
* msgq_status --
* Report on the file's status.
*
* PUBLIC: void msgq_status(SCR *, recno_t, u_int);
*/
void
msgq_status(
SCR *sp,
recno_t lno,
u_int flags)
{
recno_t last;
size_t blen, len;
int cnt, needsep;
const char *t;
char **ap, *bp, *np, *p, *s, *ep;
CHAR_T *wp;
size_t wlen;
/* Get sufficient memory. */
len = strlen(sp->frp->name);
GET_SPACE_GOTOC(sp, bp, blen, len * MAX_CHARACTER_COLUMNS + 128);
p = bp;
ep = bp + blen;
/* Convert the filename. */
CHAR2INT(sp, sp->frp->name, len + 1, wp, wlen);
/* Copy in the filename. */
for (; *wp != '\0'; ++wp) {
len = KEY_LEN(sp, *wp);
memcpy(p, KEY_NAME(sp, *wp), len);
p += len;
}
np = p;
*p++ = ':';
*p++ = ' ';
/* Copy in the argument count. */
if (F_ISSET(sp, SC_STATUS_CNT) && sp->argv != NULL) {
for (cnt = 0, ap = sp->argv; *ap != NULL; ++ap, ++cnt);
if (cnt > 1) {
(void)snprintf(p, ep - p,
msg_cat(sp, "317|%d files to edit", NULL), cnt);
p += strlen(p);
*p++ = ':';
*p++ = ' ';
}
F_CLR(sp, SC_STATUS_CNT);
}
/*
* See nvi/exf.c:file_init() for a description of how and when the
* read-only bit is set.
*
* !!!
* The historic display for "name changed" was "[Not edited]".
*/
needsep = 0;
if (F_ISSET(sp->frp, FR_NEWFILE)) {
F_CLR(sp->frp, FR_NEWFILE);
t = msg_cat(sp, "021|new file", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
} else {
if (F_ISSET(sp->frp, FR_NAMECHANGE)) {
t = msg_cat(sp, "022|name changed", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
if (F_ISSET(sp->ep, F_MODIFIED))
t = msg_cat(sp, "023|modified", &len);
else
t = msg_cat(sp, "024|unmodified", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (F_ISSET(sp->frp, FR_UNLOCKED)) {
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
t = msg_cat(sp, "025|UNLOCKED", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (O_ISSET(sp, O_READONLY)) {
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
t = msg_cat(sp, "026|readonly", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (needsep) {
*p++ = ':';
*p++ = ' ';
}
if (LF_ISSET(MSTAT_SHOWLAST)) {
if (db_last(sp, &last))
return;
if (last == 0) {
t = msg_cat(sp, "028|empty file", &len);
memcpy(p, t, len);
p += len;
} else {
t = msg_cat(sp, "027|line %lu of %lu [%ld%%]", &len);
(void)snprintf(p, ep - p, t, (u_long)lno, (u_long)last,
((u_long)lno * 100) / last);
p += strlen(p);
}
} else {
t = msg_cat(sp, "029|line %lu", &len);
(void)snprintf(p, ep - p, t, (u_long)lno);
p += strlen(p);
}
#ifdef DEBUG
(void)snprintf(p, ep - p, " (pid %lu)", (u_long)getpid());
p += strlen(p);
#endif
*p++ = '\n';
len = p - bp;
/*
* There's a nasty problem with long path names. Cscope and tags files
* can result in long paths and vi will request a continuation key from
* the user as soon as it starts the screen. Unfortunately, the user
* has already typed ahead, and chaos results. If we assume that the
* characters in the filenames and informational messages only take a
* single screen column each, we can trim the filename.
*
* XXX
* Status lines get put up at fairly awkward times. For example, when
* you do a filter read (e.g., :read ! echo foo) in the top screen of a
* split screen, we have to repaint the status lines for all the screens
* below the top screen. We don't want users having to enter continue
* characters for those screens. Make it really hard to screw this up.
*/
s = bp;
if (LF_ISSET(MSTAT_TRUNCATE) && len > sp->cols) {
for (; s < np && (*s != '/' || (p - s) > sp->cols - 3); ++s);
if (s == np) {
s = p - (sp->cols - 5);
*--s = ' ';
}
*--s = '.';
*--s = '.';
*--s = '.';
len = p - s;
}
/* Flush any waiting ex messages. */
(void)ex_fflush(sp);
sp->gp->scr_msg(sp, M_INFO, s, len);
FREE_SPACE(sp, bp, blen);
alloc_err:
return;
}
/*
* msgq --
* Display a message.
*
* PUBLIC: void msgq(SCR *, mtype_t, const char *, ...);
*/
void
msgq(
SCR *sp,
mtype_t mt,
const char *fmt,
...)
{
#ifndef NL_ARGMAX
#define __NL_ARGMAX 20 /* Set to 9 by System V. */
struct {
const char *str; /* String pointer. */
size_t arg; /* Argument number. */
size_t prefix; /* Prefix string length. */
size_t skip; /* Skipped string length. */
size_t suffix; /* Suffix string length. */
} str[__NL_ARGMAX];
#endif
static int reenter; /* STATIC: Re-entrancy check. */
GS *gp;
size_t blen, len, mlen, nlen;
const char *p;
char *bp, *mp;
va_list ap;
#ifndef NL_ARGMAX
int ch;
char *rbp, *s_rbp;
const char *t, *u;
size_t cnt1, cnt2, soff;
#endif
/*
* !!!
* It's possible to enter msg when there's no screen to hold the
* message. If sp is NULL, ignore the special cases and put the
* message out to stderr.
*/
if (sp == NULL) {
gp = NULL;
if (mt == M_BERR)
mt = M_ERR;
else if (mt == M_VINFO)
mt = M_INFO;
} else {
gp = sp->gp;
switch (mt) {
case M_BERR:
if (F_ISSET(sp, SC_VI) && !O_ISSET(sp, O_VERBOSE)) {
F_SET(gp, G_BELLSCHED);
return;
}
mt = M_ERR;
break;
case M_VINFO:
if (!O_ISSET(sp, O_VERBOSE))
return;
mt = M_INFO;
/* FALLTHROUGH */
case M_INFO:
if (F_ISSET(sp, SC_EX_SILENT))
return;
break;
case M_ERR:
case M_SYSERR:
break;
default:
abort();
}
}
/*
* It's possible to reenter msg when it allocates space. We're
* probably dead anyway, but there's no reason to drop core.
*
* XXX
* Yes, there's a race, but it should only be two instructions.
*/
if (reenter++)
return;
/* Get space for the message. */
nlen = 1024;
if (0) {
retry: FREE_SPACE(sp, bp, blen);
nlen *= 2;
}
bp = NULL;
blen = 0;
GET_SPACE_GOTOC(sp, bp, blen, nlen);
/*
* Error prefix.
*
* mp: pointer to the current next character to be written
* mlen: length of the already written characters
* blen: total length of the buffer
*/
#define REM (blen - mlen)
mp = bp;
mlen = 0;
if (mt == M_SYSERR) {
p = msg_cat(sp, "020|Error: ", &len);
if (REM < len)
goto retry;
memcpy(mp, p, len);
mp += len;
mlen += len;
}
/*
* If we're running an ex command that the user didn't enter, display
* the file name and line number prefix.
*/
if ((mt == M_ERR || mt == M_SYSERR) &&
sp != NULL && gp != NULL && gp->if_name != NULL) {
CHAR_T *wp;
size_t wlen;
CHAR2INT(sp, gp->if_name, strlen(gp->if_name) + 1, wp, wlen);
for (; *wp != '\0'; ++wp) {
len = snprintf(mp, REM, "%s", KEY_NAME(sp, *wp));
mp += len;
if ((mlen += len) > blen)
goto retry;
}
len = snprintf(mp, REM, ", %d: ", gp->if_lno);
mp += len;
if ((mlen += len) > blen)
goto retry;
}
/* If nothing to format, we're done. */
if (fmt == NULL)
goto nofmt;
fmt = msg_cat(sp, fmt, NULL);
#ifndef NL_ARGMAX
/*
* Nvi should run on machines that don't support the numbered argument
* specifications (%[digit]*$). We do this by reformatting the string
* so that we can hand it to vsprintf(3) and it will use the arguments
* in the right order. When vsprintf returns, we put the string back
* into the right order. It's undefined, according to SVID III, to mix
* numbered argument specifications with the standard style arguments,
* so this should be safe.
*
* In addition, we also need a character that is known to not occur in
* any vi message, for separating the parts of the string. As callers
* of msgq are responsible for making sure that all the non-printable
* characters are formatted for printing before calling msgq, we use a
* random non-printable character selected at terminal initialization
* time. This code isn't fast by any means, but as messages should be
* relatively short and normally have only a few arguments, it won't be
* too bad. Regardless, nobody has come up with any other solution.
*
* The result of this loop is an array of pointers into the message
* string, with associated lengths and argument numbers. The array
* is in the "correct" order, and the arg field contains the argument
* order.
*/
for (p = fmt, soff = 0; soff < __NL_ARGMAX;) {
for (t = p; *p != '\0' && *p != '%'; ++p);
if (*p == '\0')
break;
++p;
if (!isdigit(*p)) {
if (*p == '%')
++p;
continue;
}
for (u = p; *++p != '\0' && isdigit(*p););
if (*p != '$')
continue;
/* Up to, and including the % character. */
str[soff].str = t;
str[soff].prefix = u - t;
/* Up to, and including the $ character. */
str[soff].arg = atoi(u);
str[soff].skip = (p - u) + 1;
if (str[soff].arg >= __NL_ARGMAX)
goto ret;
/* Up to, and including the conversion character. */
for (u = p; (ch = *++p) != '\0';)
if (isalpha(ch) &&
strchr("diouxXfeEgGcspn", ch) != NULL)
break;
str[soff].suffix = p - u;
if (ch != '\0')
++p;
++soff;
}
/* If no magic strings, we're done. */
if (soff == 0)
goto format;
/* Get space for the reordered strings. */
if ((rbp = malloc(nlen)) == NULL)
goto ret;
s_rbp = rbp;
/*
* Reorder the strings into the message string based on argument
* order.
*
* !!!
* We ignore arguments that are out of order, i.e. if we don't find
* an argument, we continue. Assume (almost certainly incorrectly)
* that whoever created the string knew what they were doing.
*
* !!!
* Brute force "sort", but since we don't expect more than one or two
* arguments in a string, the setup cost of a fast sort will be more
* expensive than the loop.
*/
for (cnt1 = 1; cnt1 <= soff; ++cnt1)
for (cnt2 = 0; cnt2 < soff; ++cnt2)
if (cnt1 == str[cnt2].arg) {
memmove(s_rbp, str[cnt2].str, str[cnt2].prefix);
memmove(s_rbp + str[cnt2].prefix,
str[cnt2].str + str[cnt2].prefix +
str[cnt2].skip, str[cnt2].suffix);
s_rbp += str[cnt2].prefix + str[cnt2].suffix;
*s_rbp++ =
gp == NULL ? DEFAULT_NOPRINT : gp->noprint;
break;
}
*s_rbp = '\0';
fmt = rbp;
#endif
#ifndef NL_ARGMAX
format: /* Format the arguments into the string. */
#endif
va_start(ap, fmt);
len = vsnprintf(mp, REM, fmt, ap);
va_end(ap);
if (len >= nlen)
goto retry;
#ifndef NL_ARGMAX
if (soff == 0)
goto nofmt;
/*
* Go through the resulting string, and, for each separator character
* separated string, enter its new starting position and length in the
* array.
*/
for (p = t = mp, cnt1 = 1,
ch = gp == NULL ? DEFAULT_NOPRINT : gp->noprint; *p != '\0'; ++p)
if (*p == ch) {
for (cnt2 = 0; cnt2 < soff; ++cnt2)
if (str[cnt2].arg == cnt1)
break;
str[cnt2].str = t;
str[cnt2].prefix = p - t;
t = p + 1;
++cnt1;
}
/*
* Reorder the strings once again, putting them back into the
* message buffer.
*
* !!!
* Note, the length of the message gets decremented once for
* each substring, when we discard the separator character.
*/
for (s_rbp = rbp, cnt1 = 0; cnt1 < soff; ++cnt1) {
memmove(rbp, str[cnt1].str, str[cnt1].prefix);
rbp += str[cnt1].prefix;
--len;
}
memmove(mp, s_rbp, rbp - s_rbp);
/* Free the reordered string memory. */
free(s_rbp);
#endif
nofmt: mp += len;
if ((mlen += len) > blen)
goto retry;
if (mt == M_SYSERR) {
len = snprintf(mp, REM, ": %s", strerror(errno));
mp += len;
if ((mlen += len) > blen)
goto retry;
mt = M_ERR;
}
/* Add trailing newline. */
if ((mlen += 1) > blen)
goto retry;
*mp = '\n';
if (sp != NULL)
(void)ex_fflush(sp);
if (gp != NULL)
gp->scr_msg(sp, mt, bp, mlen);
else
(void)fprintf(stderr, "%.*s", (int)mlen, bp);
/* Cleanup. */
#ifndef NL_ARGMAX
ret:
#endif
FREE_SPACE(sp, bp, blen);
alloc_err:
reenter = 0;
}
/*
* put --
* Put text buffer contents into the file.
*
* PUBLIC: int put __P((SCR *, CB *, CHAR_T *, MARK *, MARK *, int));
*/
int
put(SCR *sp, CB *cbp, ARG_CHAR_T *namep, MARK *cp, MARK *rp, int append)
{
ARG_CHAR_T name;
TEXT *ltp, *tp;
db_recno_t lno;
size_t blen, clen, len;
int rval;
CHAR_T *bp, *t;
CHAR_T *p;
if (cbp == NULL) {
if (namep == NULL) {
cbp = sp->wp->dcbp;
if (cbp == NULL) {
msgq(sp, M_ERR,
"053|The default buffer is empty");
return (1);
}
} else {
name = *namep;
CBNAME(sp, cbp, name);
if (cbp == NULL) {
msgq(sp, M_ERR, "054|Buffer %s is empty",
KEY_NAME(sp, name));
return (1);
}
}
}
tp = cbp->textq.cqh_first;
/*
* It's possible to do a put into an empty file, meaning that the cut
* buffer simply becomes the file. It's a special case so that we can
* ignore it in general.
*
* !!!
* Historically, pasting into a file with no lines in vi would preserve
* the single blank line. This is surely a result of the fact that the
* historic vi couldn't deal with a file that had no lines in it. This
* implementation treats that as a bug, and does not retain the blank
* line.
*
* Historical practice is that the cursor ends at the first character
* in the file.
*/
if (cp->lno == 1) {
if (db_last(sp, &lno))
return (1);
if (lno == 0) {
for (; tp != (void *)&cbp->textq;
++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
if (db_append(sp, 1, lno, tp->lb, tp->len))
return (1);
rp->lno = 1;
rp->cno = 0;
return (0);
}
}
/* If a line mode buffer, append each new line into the file. */
if (F_ISSET(cbp, CB_LMODE)) {
lno = append ? cp->lno : cp->lno - 1;
rp->lno = lno + 1;
for (; tp != (void *)&cbp->textq;
++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
if (db_append(sp, 1, lno, tp->lb, tp->len))
return (1);
rp->cno = 0;
(void)nonblank(sp, rp->lno, &rp->cno);
return (0);
}
/*
* If buffer was cut in character mode, replace the current line with
* one built from the portion of the first line to the left of the
* split plus the first line in the CB. Append each intermediate line
* in the CB. Append a line built from the portion of the first line
* to the right of the split plus the last line in the CB.
*
* Get the first line.
*/
lno = cp->lno;
if (db_get(sp, lno, DBG_FATAL, &p, &len))
return (1);
GET_SPACE_RETW(sp, bp, blen, tp->len + len + 1);
t = bp;
/* Original line, left of the split. */
if (len > 0 && (clen = cp->cno + (append ? 1 : 0)) > 0) {
MEMCPYW(bp, p, clen);
p += clen;
t += clen;
}
/* First line from the CB. */
if (tp->len != 0) {
MEMCPYW(t, tp->lb, tp->len);
t += tp->len;
}
/* Calculate length left in the original line. */
clen = len == 0 ? 0 : len - (cp->cno + (append ? 1 : 0));
/*
* !!!
* In the historical 4BSD version of vi, character mode puts within
* a single line have two cursor behaviors: if the put is from the
* unnamed buffer, the cursor moves to the character inserted which
* appears last in the file. If the put is from a named buffer,
* the cursor moves to the character inserted which appears first
* in the file. In System III/V, it was changed at some point and
* the cursor always moves to the first character. In both versions
* of vi, character mode puts that cross line boundaries leave the
* cursor on the first character. Nvi implements the System III/V
* behavior, and expect POSIX.2 to do so as well.
*/
rp->lno = lno;
rp->cno = len == 0 ? 0 : sp->cno + (append && tp->len ? 1 : 0);
/*
* If no more lines in the CB, append the rest of the original
* line and quit. Otherwise, build the last line before doing
* the intermediate lines, because the line changes will lose
* the cached line.
*/
if (tp->q.cqe_next == (void *)&cbp->textq) {
if (clen > 0) {
MEMCPYW(t, p, clen);
t += clen;
}
if (db_set(sp, lno, bp, t - bp))
goto err;
if (sp->rptlchange != lno) {
sp->rptlchange = lno;
++sp->rptlines[L_CHANGED];
}
} else {
/*
* Have to build both the first and last lines of the
* put before doing any sets or we'll lose the cached
* line. Build both the first and last lines in the
* same buffer, so we don't have to have another buffer
* floating around.
*
* Last part of original line; check for space, reset
* the pointer into the buffer.
*/
ltp = cbp->textq.cqh_last;
len = t - bp;
ADD_SPACE_RETW(sp, bp, blen, ltp->len + clen);
t = bp + len;
/* Add in last part of the CB. */
MEMCPYW(t, ltp->lb, ltp->len);
if (clen)
MEMCPYW(t + ltp->len, p, clen);
clen += ltp->len;
/*
* Now: bp points to the first character of the first
* line, t points to the last character of the last
* line, t - bp is the length of the first line, and
* clen is the length of the last. Just figured you'd
* want to know.
*
* Output the line replacing the original line.
*/
if (db_set(sp, lno, bp, t - bp))
goto err;
if (sp->rptlchange != lno) {
sp->rptlchange = lno;
++sp->rptlines[L_CHANGED];
}
/* Output any intermediate lines in the CB. */
for (tp = tp->q.cqe_next;
tp->q.cqe_next != (void *)&cbp->textq;
++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
if (db_append(sp, 1, lno, tp->lb, tp->len))
goto err;
if (db_append(sp, 1, lno, t, clen))
goto err;
++sp->rptlines[L_ADDED];
}
rval = 0;
if (0)
err: rval = 1;
FREE_SPACEW(sp, bp, blen);
return (rval);
}
/*
* vs_output --
* Output the text to the screen.
*/
static void
vs_output(SCR *sp, mtype_t mtype, const char *line, int llen)
{
unsigned char *kp;
GS *gp;
VI_PRIVATE *vip;
size_t chlen, notused;
int ch, len, rlen, tlen;
const char *p, *t;
char *cbp, *ecbp, cbuf[128];
gp = sp->gp;
vip = VIP(sp);
for (p = line, rlen = llen; llen > 0;) {
/* Get the next physical line. */
if ((p = memchr(line, '\n', llen)) == NULL)
len = llen;
else
len = p - line;
/*
* The max is sp->cols characters, and we may have already
* written part of the line.
*/
if (len + vip->lcontinue > sp->cols)
len = sp->cols - vip->lcontinue;
/*
* If the first line output, do nothing. If the second line
* output, draw the divider line. If drew a full screen, we
* remove the divider line. If it's a continuation line, move
* to the continuation point, else, move the screen up.
*/
if (vip->lcontinue == 0) {
if (!IS_ONELINE(sp)) {
if (vip->totalcount == 1) {
(void)gp->scr_move(sp,
LASTLINE(sp) - 1, 0);
(void)gp->scr_clrtoeol(sp);
(void)vs_divider(sp);
F_SET(vip, VIP_DIVIDER);
++vip->totalcount;
++vip->linecount;
}
if (vip->totalcount == sp->t_maxrows &&
F_ISSET(vip, VIP_DIVIDER)) {
--vip->totalcount;
--vip->linecount;
F_CLR(vip, VIP_DIVIDER);
}
}
if (vip->totalcount != 0)
vs_scroll(sp, NULL, SCROLL_W_QUIT);
(void)gp->scr_move(sp, LASTLINE(sp), 0);
++vip->totalcount;
++vip->linecount;
if (INTERRUPTED(sp))
break;
} else
(void)gp->scr_move(sp, LASTLINE(sp), vip->lcontinue);
/* Error messages are in inverse video. */
if (mtype == M_ERR)
(void)gp->scr_attr(sp, SA_INVERSE, 1);
/* Display the line, doing character translation. */
#define FLUSH { \
*cbp = '\0'; \
(void)gp->scr_addstr(sp, cbuf, cbp - cbuf); \
cbp = cbuf; \
}
ecbp = (cbp = cbuf) + sizeof(cbuf) - 1;
for (t = line, tlen = len; tlen--; ++t) {
ch = *t;
/*
* Replace tabs with spaces, there are places in
* ex that do column calculations without looking
* at <tabs> -- and all routines that care about
* <tabs> do their own expansions. This catches
* <tabs> in things like tag search strings.
*/
if (ch == '\t')
ch = ' ';
chlen = KEY_LEN(sp, ch);
if (cbp + chlen >= ecbp)
FLUSH;
for (kp = KEY_NAME(sp, ch); chlen--;)
*cbp++ = *kp++;
}
if (cbp > cbuf)
FLUSH;
if (mtype == M_ERR)
(void)gp->scr_attr(sp, SA_INVERSE, 0);
/* Clear the rest of the line. */
(void)gp->scr_clrtoeol(sp);
/* If we loop, it's a new line. */
vip->lcontinue = 0;
/* Reset for the next line. */
line += len;
llen -= len;
if (p != NULL) {
++line;
--llen;
}
}
/* Set up next continuation line. */
if (p == NULL)
gp->scr_cursor(sp, ¬used, &vip->lcontinue);
}
/*
* vi --
* Main vi command loop.
*
* PUBLIC: int vi __P((SCR **));
*/
int
vi(SCR **spp)
{
GS *gp;
MARK abs;
SCR *next, *sp;
VICMD cmd = { 0 }, *vp;
VI_PRIVATE *vip;
int comcount, mapped, rval;
/* Get the first screen. */
sp = *spp;
gp = sp->gp;
/* Point to the command structure. */
vp = &cmd;
/* Reset strange attraction. */
F_SET(vp, VM_RCM_SET);
/* Initialize the vi screen. */
if (v_init(sp))
return (1);
/* Set the focus. */
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
for (vip = VIP(sp), rval = 0;;) {
/* Resolve messages. */
if (!MAPPED_KEYS_WAITING(sp) && vs_resolve(sp, NULL, 0))
goto ret;
/*
* If not skipping a refresh, return to command mode and
* refresh the screen.
*/
if (F_ISSET(vip, VIP_S_REFRESH))
F_CLR(vip, VIP_S_REFRESH);
else {
sp->showmode = SM_COMMAND;
if (vs_refresh(sp, 0))
goto ret;
}
/* Set the new favorite position. */
if (F_ISSET(vp, VM_RCM_SET | VM_RCM_SETFNB | VM_RCM_SETNNB)) {
F_CLR(vip, VIP_RCM_LAST);
(void)vs_column(sp, &sp->rcm);
}
/*
* If not currently in a map, log the cursor position,
* and set a flag so that this command can become the
* DOT command.
*/
if (MAPPED_KEYS_WAITING(sp))
mapped = 1;
else {
if (log_cursor(sp))
goto err;
mapped = 0;
}
/*
* There may be an ex command waiting, and we returned here
* only because we exited a screen or file. In this case,
* we simply go back into the ex parser.
*/
if (EXCMD_RUNNING(gp)) {
vp->kp = &vikeys[':'];
goto ex_continue;
}
/* Refresh the command structure. */
memset(vp, 0, sizeof(VICMD));
/*
* We get a command, which may or may not have an associated
* motion. If it does, we get it too, calling its underlying
* function to get the resulting mark. We then call the
* command setting the cursor to the resulting mark.
*
* !!!
* Vi historically flushed mapped characters on error, but
* entering extra <escape> characters at the beginning of
* a map wasn't considered an error -- in fact, users would
* put leading <escape> characters in maps to clean up vi
* state before the map was interpreted. Beauty!
*/
switch (v_cmd(sp, DOT, vp, NULL, &comcount, &mapped)) {
case GC_ERR:
goto err;
case GC_ERR_NOFLUSH:
goto gc_err_noflush;
case GC_EVENT:
goto gc_event;
case GC_FATAL:
goto ret;
case GC_INTERRUPT:
goto intr;
case GC_OK:
break;
}
/* Check for security setting. */
if (F_ISSET(vp->kp, V_SECURE) && O_ISSET(sp, O_SECURE)) {
ex_emsg(sp, KEY_NAME(sp, vp->key), EXM_SECURE);
goto err;
}
/*
* Historical practice: if a dot command gets a new count,
* any motion component goes away, i.e. "d3w2." deletes a
* total of 5 words.
*/
if (F_ISSET(vp, VC_ISDOT) && comcount)
DOTMOTION->count = 1;
/* Copy the key flags into the local structure. */
F_SET(vp, vp->kp->flags);
/* Prepare to set the previous context. */
if (F_ISSET(vp, V_ABS | V_ABS_C | V_ABS_L)) {
abs.lno = sp->lno;
abs.cno = sp->cno;
}
/*
* Set the three cursor locations to the current cursor. The
* underlying routines don't bother if the cursor doesn't move.
* This also handles line commands (e.g. Y) defaulting to the
* current line.
*/
vp->m_start.lno = vp->m_stop.lno = vp->m_final.lno = sp->lno;
vp->m_start.cno = vp->m_stop.cno = vp->m_final.cno = sp->cno;
/*
* Do any required motion; v_motion sets the from MARK and the
* line mode flag, as well as the VM_RCM flags.
*/
if (F_ISSET(vp, V_MOTION) &&
v_motion(sp, DOTMOTION, vp, &mapped)) {
if (INTERRUPTED(sp))
goto intr;
goto err;
}
/*
* If a count is set and the command is line oriented, set the
* to MARK here relative to the cursor/from MARK. This is for
* commands that take both counts and motions, i.e. "4yy" and
* "y%". As there's no way the command can know which the user
* did, we have to do it here. (There are commands that are
* line oriented and that take counts ("#G", "#H"), for which
* this calculation is either completely meaningless or wrong.
* Each command must validate the value for itself.
*/
if (F_ISSET(vp, VC_C1SET) && F_ISSET(vp, VM_LMODE))
vp->m_stop.lno += vp->count - 1;
/* Increment the command count. */
++sp->ccnt;
#if defined(DEBUG) && defined(COMLOG)
v_comlog(sp, vp);
#endif
/* Call the function. */
ex_continue: if (vp->kp->func(sp, vp))
goto err;
gc_event:
#ifdef DEBUG
/* Make sure no function left the temporary space locked. */
if (F_ISSET(gp, G_TMP_INUSE)) {
F_CLR(gp, G_TMP_INUSE);
msgq(sp, M_ERR,
"232|vi: temporary buffer not released");
}
#endif
/*
* If we're exiting this screen, move to the next one, or, if
* there aren't any more, return to the main editor loop. The
* ordering is careful, don't discard the contents of sp until
* the end.
*/
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (file_end(sp, NULL, F_ISSET(sp, SC_EXIT_FORCE)))
goto ret;
if (vs_discard(sp, &next))
goto ret;
if (next == NULL && vs_swap(sp, &next, NULL))
goto ret;
*spp = next;
if (screen_end(sp))
goto ret;
if (next == NULL)
break;
/* Switch screens, change focus. */
sp = next;
vip = VIP(sp);
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
/* Don't trust the cursor. */
F_SET(vip, VIP_CUR_INVALID);
continue;
}
/*
* Set the dot command structure.
*
* !!!
* Historically, commands which used mapped keys did not
* set the dot command, with the exception of the text
* input commands.
*/
if (F_ISSET(vp, V_DOT) && !mapped) {
*DOT = cmd;
F_SET(DOT, VC_ISDOT);
/*
* If a count was supplied for both the command and
* its motion, the count was used only for the motion.
* Turn the count back on for the dot structure.
*/
if (F_ISSET(vp, VC_C1RESET))
F_SET(DOT, VC_C1SET);
/* VM flags aren't retained. */
F_CLR(DOT, VM_COMMASK | VM_RCM_MASK);
}
/*
* Some vi row movements are "attracted" to the last position
* set, i.e. the VM_RCM commands are moths to the VM_RCM_SET
* commands' candle. If the movement is to the EOL the vi
* command handles it. If it's to the beginning, we handle it
* here.
*
* Note, some commands (e.g. _, ^) don't set the VM_RCM_SETFNB
* flag, but do the work themselves. The reason is that they
* have to modify the column in case they're being used as a
* motion component. Other similar commands (e.g. +, -) don't
* have to modify the column because they are always line mode
* operations when used as motions, so the column number isn't
* of any interest.
*
* Does this totally violate the screen and editor layering?
* You betcha. As they say, if you think you understand it,
* you don't.
*/
switch (F_ISSET(vp, VM_RCM_MASK)) {
case 0:
case VM_RCM_SET:
break;
case VM_RCM:
vp->m_final.cno = vs_rcm(sp,
vp->m_final.lno, F_ISSET(vip, VIP_RCM_LAST));
break;
case VM_RCM_SETLAST:
F_SET(vip, VIP_RCM_LAST);
break;
case VM_RCM_SETFNB:
vp->m_final.cno = 0;
/* FALLTHROUGH */
case VM_RCM_SETNNB:
if (nonblank(sp, vp->m_final.lno, &vp->m_final.cno))
goto err;
break;
default:
abort();
}
/* Update the cursor. */
sp->lno = vp->m_final.lno;
sp->cno = vp->m_final.cno;
/*
* Set the absolute mark -- set even if a tags or similar
* command, since the tag may be moving to the same file.
*/
if ((F_ISSET(vp, V_ABS) ||
(F_ISSET(vp, V_ABS_L) && sp->lno != abs.lno) ||
(F_ISSET(vp, V_ABS_C) &&
(sp->lno != abs.lno || sp->cno != abs.cno))) &&
mark_set(sp, ABSMARK1, &abs, 1))
goto err;
if (0) {
err: if (v_event_flush(sp, CH_MAPPED))
msgq(sp, M_BERR,
"110|Vi command failed: mapped keys discarded");
}
/*
* Check and clear interrupts. There's an obvious race, but
* it's not worth fixing.
*/
gc_err_noflush: if (INTERRUPTED(sp)) {
intr: CLR_INTERRUPT(sp);
if (v_event_flush(sp, CH_MAPPED))
msgq(sp, M_ERR,
"231|Interrupted: mapped keys discarded");
else
msgq(sp, M_ERR, "236|Interrupted");
}
/* If the last command switched screens, update. */
if (F_ISSET(sp, SC_SSWITCH)) {
F_CLR(sp, SC_SSWITCH);
/*
* If the current screen is still displayed, it will
* need a new status line.
*/
F_SET(sp, SC_STATUS);
/* Switch screens, change focus. */
sp = sp->nextdisp;
vip = VIP(sp);
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
/* Don't trust the cursor. */
F_SET(vip, VIP_CUR_INVALID);
/* Refresh so we can display messages. */
if (vs_refresh(sp, 1))
return (1);
}
/* If the last command switched files, change focus. */
if (F_ISSET(sp, SC_FSWITCH)) {
F_CLR(sp, SC_FSWITCH);
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
}
/* If leaving vi, return to the main editor loop. */
if (F_ISSET(gp, G_SRESTART) || F_ISSET(sp, SC_EX)) {
*spp = sp;
v_dtoh(sp);
gp->scr_discard(sp, NULL);
break;
}
}
if (0)
ret: rval = 1;
return (rval);
}
/*
* v_cmd --
*
* The command structure for vi is less complex than ex (and don't think
* I'm not grateful!) The command syntax is:
*
* [count] [buffer] [count] key [[motion] | [buffer] [character]]
*
* and there are several special cases. The motion value is itself a vi
* command, with the syntax:
*
* [count] key [character]
*/
static gcret_t
v_cmd(
SCR *sp,
VICMD *dp,
VICMD *vp,
VICMD *ismotion, /* Previous key if getting motion component. */
int *comcountp,
int *mappedp)
{
enum { COMMANDMODE, ISPARTIAL, NOTPARTIAL } cpart;
EVENT ev;
VIKEYS const *kp;
gcret_t gcret;
u_int flags;
CHAR_T key;
char *s;
/*
* Get a key.
*
* <escape> cancels partial commands, i.e. a command where at least
* one non-numeric character has been entered. Otherwise, it beeps
* the terminal.
*
* !!!
* POSIX 1003.2-1992 explicitly disallows cancelling commands where
* all that's been entered is a number, requiring that the terminal
* be alerted.
*/
cpart = ismotion == NULL ? COMMANDMODE : ISPARTIAL;
if ((gcret =
v_key(sp, ismotion == NULL, &ev, EC_MAPCOMMAND)) != GC_OK) {
if (gcret == GC_EVENT)
vp->ev = ev;
return (gcret);
}
if (ev.e_value == K_ESCAPE)
goto esc;
if (F_ISSET(&ev.e_ch, CH_MAPPED))
*mappedp = 1;
key = ev.e_c;
if (ismotion == NULL)
cpart = NOTPARTIAL;
/* Pick up an optional buffer. */
if (key == '"') {
cpart = ISPARTIAL;
if (ismotion != NULL) {
v_emsg(sp, NULL, VIM_COMBUF);
return (GC_ERR);
}
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
KEY(key, EC_MAPCOMMAND);
}
/*
* Pick up an optional count, where a leading 0 is not a count,
* it's a command.
*/
if (ISDIGIT(key) && key != '0') {
if (v_count(sp, key, &vp->count))
return (GC_ERR);
F_SET(vp, VC_C1SET);
*comcountp = 1;
KEY(key, EC_MAPCOMMAND);
} else
*comcountp = 0;
/* Pick up optional buffer. */
if (key == '"') {
cpart = ISPARTIAL;
if (F_ISSET(vp, VC_BUFFER)) {
msgq(sp, M_ERR, "234|Only one buffer may be specified");
return (GC_ERR);
}
if (ismotion != NULL) {
v_emsg(sp, NULL, VIM_COMBUF);
return (GC_ERR);
}
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
KEY(key, EC_MAPCOMMAND);
}
/* Check for an OOB command key. */
cpart = ISPARTIAL;
if (key > MAXVIKEY) {
v_emsg(sp, KEY_NAME(sp, key), VIM_NOCOM);
return (GC_ERR);
}
kp = &vikeys[vp->key = key];
/*
* !!!
* Historically, D accepted and then ignored a count. Match it.
*/
if (vp->key == 'D' && F_ISSET(vp, VC_C1SET)) {
*comcountp = 0;
vp->count = 0;
F_CLR(vp, VC_C1SET);
}
/* Check for command aliases. */
if (kp->func == NULL && (kp = v_alias(sp, vp, kp)) == NULL)
return (GC_ERR);
/* The tildeop option makes the ~ command take a motion. */
if (key == '~' && O_ISSET(sp, O_TILDEOP))
kp = &tmotion;
vp->kp = kp;
/*
* Find the command. The only legal command with no underlying
* function is dot. It's historic practice that <escape> doesn't
* just erase the preceding number, it beeps the terminal as well.
* It's a common problem, so just beep the terminal unless verbose
* was set.
*/
if (kp->func == NULL) {
if (key != '.') {
v_emsg(sp, KEY_NAME(sp, key),
ev.e_value == K_ESCAPE ? VIM_NOCOM_B : VIM_NOCOM);
return (GC_ERR);
}
/* If called for a motion command, stop now. */
if (dp == NULL)
goto usage;
/*
* !!!
* If a '.' is immediately entered after an undo command, we
* replay the log instead of redoing the last command. This
* is necessary because 'u' can't set the dot command -- see
* vi/v_undo.c:v_undo for details.
*/
if (VIP(sp)->u_ccnt == sp->ccnt) {
vp->kp = &vikeys['u'];
F_SET(vp, VC_ISDOT);
return (GC_OK);
}
/* Otherwise, a repeatable command must have been executed. */
if (!F_ISSET(dp, VC_ISDOT)) {
msgq(sp, M_ERR, "208|No command to repeat");
return (GC_ERR);
}
/* Set new count/buffer, if any, and return. */
if (F_ISSET(vp, VC_C1SET)) {
F_SET(dp, VC_C1SET);
dp->count = vp->count;
}
if (F_ISSET(vp, VC_BUFFER))
dp->buffer = vp->buffer;
*vp = *dp;
return (GC_OK);
}
/* Set the flags based on the command flags. */
flags = kp->flags;
/* Check for illegal count. */
if (F_ISSET(vp, VC_C1SET) && !LF_ISSET(V_CNT))
goto usage;
/* Illegal motion command. */
if (ismotion == NULL) {
/* Illegal buffer. */
if (!LF_ISSET(V_OBUF) && F_ISSET(vp, VC_BUFFER))
goto usage;
/* Required buffer. */
if (LF_ISSET(V_RBUF)) {
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
}
}
/*
* Special case: '[', ']' and 'Z' commands. Doesn't the fact that
* the *single* characters don't mean anything but the *doubled*
* characters do, just frost your shorts?
*/
if (vp->key == '[' || vp->key == ']' || vp->key == 'Z') {
/*
* Historically, half entered [[, ]] or Z commands weren't
* cancelled by <escape>, the terminal was beeped instead.
* POSIX.2-1992 probably didn't notice, and requires that
* they be cancelled instead of beeping. Seems fine to me.
*
* Don't set the EC_MAPCOMMAND flag, apparently ] is a popular
* vi meta-character, and we don't want the user to wait while
* we time out a possible mapping. This *appears* to match
* historic vi practice, but with mapping characters, You Just
* Never Know.
*/
KEY(key, 0);
if (vp->key != key) {
usage: if (ismotion == NULL)
s = kp->usage;
else if (ismotion->key == '~' && O_ISSET(sp, O_TILDEOP))
s = tmotion.usage;
else
s = vikeys[ismotion->key].usage;
v_emsg(sp, s, VIM_USAGE);
return (GC_ERR);
}
}
/* Special case: 'z' command. */
if (vp->key == 'z') {
KEY(vp->character, 0);
if (ISDIGIT(vp->character)) {
if (v_count(sp, vp->character, &vp->count2))
return (GC_ERR);
F_SET(vp, VC_C2SET);
KEY(vp->character, 0);
}
}
/*
* Commands that have motion components can be doubled to imply the
* current line.
*/
if (ismotion != NULL && ismotion->key != key && !LF_ISSET(V_MOVE)) {
msgq(sp, M_ERR, "210|%s may not be used as a motion command",
KEY_NAME(sp, key));
return (GC_ERR);
}
/* Pick up required trailing character. */
if (LF_ISSET(V_CHAR))
KEY(vp->character, 0);
/* Get any associated cursor word. */
if (F_ISSET(kp, V_KEYW) && v_curword(sp))
return (GC_ERR);
return (GC_OK);
esc: switch (cpart) {
case COMMANDMODE:
msgq(sp, M_BERR, "211|Already in command mode");
return (GC_ERR_NOFLUSH);
case ISPARTIAL:
break;
case NOTPARTIAL:
(void)sp->gp->scr_bell(sp);
break;
}
return (GC_ERR);
}
/*
* vs_line --
* Update one line on the screen.
*
* PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
*/
int
vs_line(SCR *sp, SMAP *smp, size_t *yp, size_t *xp)
{
unsigned char *kp;
GS *gp;
SMAP *tsmp;
size_t chlen = 0, cno_cnt, cols_per_screen, len, nlen;
size_t offset_in_char, offset_in_line, oldx, oldy;
size_t scno, skip_cols, skip_screens;
int dne, is_cached, is_partial, is_tab, no_draw;
int list_tab, list_dollar;
CHAR_T *p;
CHAR_T *cbp, *ecbp, cbuf[128];
ARG_CHAR_T ch = L('\0');
#if defined(DEBUG) && 0
vtrace(sp, "vs_line: row %u: line: %u off: %u\n",
smp - HMAP, smp->lno, smp->off);
#endif
/*
* If ex modifies the screen after ex output is already on the screen,
* don't touch it -- we'll get scrolling wrong, at best.
*/
no_draw = 0;
if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)
no_draw = 1;
if (F_ISSET(sp, SC_SCR_EXWROTE) && (size_t)(smp - HMAP) != LASTLINE(sp))
no_draw = 1;
/*
* Assume that, if the cache entry for the line is filled in, the
* line is already on the screen, and all we need to do is return
* the cursor position. If the calling routine doesn't need the
* cursor position, we can just return.
*/
is_cached = SMAP_CACHE(smp);
if (yp == NULL && (is_cached || no_draw))
return (0);
/*
* A nasty side effect of this routine is that it returns the screen
* position for the "current" character. Not pretty, but this is the
* only routine that really knows what's out there.
*
* Move to the line. This routine can be called by vs_sm_position(),
* which uses it to fill in the cache entry so it can figure out what
* the real contents of the screen are. Because of this, we have to
* return to whereever we started from.
*/
gp = sp->gp;
(void)gp->scr_cursor(sp, &oldy, &oldx);
(void)gp->scr_move(sp, smp - HMAP, 0);
/* Get the line. */
dne = db_get(sp, smp->lno, 0, &p, &len);
/*
* Special case if we're printing the info/mode line. Skip printing
* the leading number, as well as other minor setup. The only time
* this code paints the mode line is when the user is entering text
* for a ":" command, so we can put the code here instead of dealing
* with the empty line logic below. This is a kludge, but it's pretty
* much confined to this module.
*
* Set the number of columns for this screen.
* Set the number of chars or screens to skip until a character is to
* be displayed.
*/
cols_per_screen = sp->cols;
if (O_ISSET(sp, O_LEFTRIGHT)) {
skip_screens = 0;
skip_cols = smp->coff;
} else {
skip_screens = smp->soff - 1;
skip_cols = skip_screens * cols_per_screen;
}
list_tab = O_ISSET(sp, O_LIST);
if (F_ISSET(sp, SC_TINPUT_INFO))
list_dollar = 0;
else {
list_dollar = list_tab;
/*
* If O_NUMBER is set, the line doesn't exist and it's line
* number 1, i.e., an empty file, display the line number.
*
* If O_NUMBER is set, the line exists and the first character
* on the screen is the first character in the line, display
* the line number.
*
* !!!
* If O_NUMBER set, decrement the number of columns in the
* first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
* rest of the code expects this to reflect the number of
* columns in the first screen, regardless of the number of
* columns we're going to skip.
*/
if (O_ISSET(sp, O_NUMBER)) {
cols_per_screen -= O_NUMBER_LENGTH;
if ((!dne || smp->lno == 1) && skip_cols == 0) {
nlen = snprintf((char*)cbuf,
sizeof(cbuf), O_NUMBER_FMT,
(unsigned long)smp->lno);
(void)gp->scr_addstr(sp, (char*)cbuf, nlen);
}
}
}
/*
* Special case non-existent lines and the first line of an empty
* file. In both cases, the cursor position is 0, but corrected
* as necessary for the O_NUMBER field, if it was displayed.
*/
if (dne || len == 0) {
/* Fill in the cursor. */
if (yp != NULL && smp->lno == sp->lno) {
*yp = smp - HMAP;
*xp = sp->cols - cols_per_screen;
}
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
/* Set line cache information. */
smp->c_sboff = smp->c_eboff = 0;
smp->c_scoff = smp->c_eclen = 0;
/*
* Lots of special cases for empty lines, but they only apply
* if we're displaying the first screen of the line.
*/
if (skip_cols == 0) {
if (dne) {
if (smp->lno == 1) {
if (list_dollar) {
ch = L('$');
goto empty;
}
} else {
ch = L('~');
goto empty;
}
} else
if (list_dollar) {
ch = L('$');
empty: (void)gp->scr_addstr(sp,
(const char *)KEY_NAME(sp, ch),
KEY_LEN(sp, ch));
}
}
(void)gp->scr_clrtoeol(sp);
(void)gp->scr_move(sp, oldy, oldx);
return (0);
}
/* If we shortened this line in another screen, the cursor
* position may have fallen off.
*/
if (sp->lno == smp->lno && sp->cno >= len)
sp->cno = len - 1;
/*
* If we just wrote this or a previous line, we cached the starting
* and ending positions of that line. The way it works is we keep
* information about the lines displayed in the SMAP. If we're
* painting the screen in the forward direction, this saves us from
* reformatting the physical line for every line on the screen. This
* wins big on binary files with 10K lines.
*
* Test for the first screen of the line, then the current screen line,
* then the line behind us, then do the hard work. Note, it doesn't
* do us any good to have a line in front of us -- it would be really
* hard to try and figure out tabs in the reverse direction, i.e. how
* many spaces a tab takes up in the reverse direction depends on
* what characters preceded it.
*
* Test for the first screen of the line.
*/
if (skip_cols == 0) {
smp->c_sboff = offset_in_line = 0;
smp->c_scoff = offset_in_char = 0;
p = &p[offset_in_line];
goto display;
}
/* Test to see if we've seen this exact line before. */
if (is_cached) {
offset_in_line = smp->c_sboff;
offset_in_char = smp->c_scoff;
p = &p[offset_in_line];
/* Set cols_per_screen to 2nd and later line length. */
if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
cols_per_screen = sp->cols;
goto display;
}
/* Test to see if we saw an earlier part of this line before. */
if (smp != HMAP &&
SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
if (tsmp->c_eclen != tsmp->c_ecsize) {
offset_in_line = tsmp->c_eboff;
offset_in_char = tsmp->c_eclen;
} else {
offset_in_line = tsmp->c_eboff + 1;
offset_in_char = 0;
}
/* Put starting info for this line in the cache. */
smp->c_sboff = offset_in_line;
smp->c_scoff = offset_in_char;
p = &p[offset_in_line];
/* Set cols_per_screen to 2nd and later line length. */
if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
cols_per_screen = sp->cols;
goto display;
}
scno = 0;
offset_in_line = 0;
offset_in_char = 0;
/* Do it the hard way, for leftright scrolling screens. */
if (O_ISSET(sp, O_LEFTRIGHT)) {
for (; offset_in_line < len; ++offset_in_line) {
chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
TAB_OFF(scno) : KEY_COL(sp, ch);
if ((scno += chlen) >= skip_cols)
break;
}
/* Set cols_per_screen to 2nd and later line length. */
cols_per_screen = sp->cols;
/* Put starting info for this line in the cache. */
if (offset_in_line >= len) {
smp->c_sboff = offset_in_line;
smp->c_scoff = 255;
} else if (scno != skip_cols) {
smp->c_sboff = offset_in_line;
smp->c_scoff =
offset_in_char = chlen - (scno - skip_cols);
--p;
} else {
smp->c_sboff = ++offset_in_line;
smp->c_scoff = 0;
}
}
/* Do it the hard way, for historic line-folding screens. */
else {
for (; offset_in_line < len; ++offset_in_line) {
chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
TAB_OFF(scno) : KEY_COL(sp, ch);
if ((scno += chlen) < cols_per_screen)
continue;
scno -= cols_per_screen;
/* Set cols_per_screen to 2nd and later line length. */
cols_per_screen = sp->cols;
/*
* If crossed the last skipped screen boundary, start
* displaying the characters.
*/
if (--skip_screens == 0)
break;
}
/* Put starting info for this line in the cache. */
if (scno != 0) {
smp->c_sboff = offset_in_line;
smp->c_scoff = offset_in_char = chlen - scno;
--p;
} else {
smp->c_sboff = ++offset_in_line;
smp->c_scoff = 0;
}
}
display:
/*
* Set the number of characters to skip before reaching the cursor
* character. Offset by 1 and use 0 as a flag value. Vs_line is
* called repeatedly with a valid pointer to a cursor position.
* Don't fill anything in unless it's the right line and the right
* character, and the right part of the character...
*/
if (yp == NULL ||
smp->lno != sp->lno || sp->cno < offset_in_line ||
offset_in_line + cols_per_screen < sp->cno) {
cno_cnt = 0;
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
} else
cno_cnt = (sp->cno - offset_in_line) + 1;
/* This is the loop that actually displays characters. */
ecbp = (cbp = cbuf) + sizeof(cbuf)/sizeof(CHAR_T) - 1;
for (is_partial = 0, scno = 0;
offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
if ((ch = (UCHAR_T)*p++) == L('\t') && !list_tab) {
scno += chlen = TAB_OFF(scno) - offset_in_char;
is_tab = 1;
} else {
scno += chlen = KEY_COL(sp, ch) - offset_in_char;
is_tab = 0;
}
/*
* Only display up to the right-hand column. Set a flag if
* the entire character wasn't displayed for use in setting
* the cursor. If reached the end of the line, set the cache
* info for the screen. Don't worry about there not being
* characters to display on the next screen, its lno/off won't
* match up in that case.
*/
if (scno >= cols_per_screen) {
if (is_tab == 1) {
chlen -= scno - cols_per_screen;
smp->c_ecsize = smp->c_eclen = chlen;
scno = cols_per_screen;
} else {
smp->c_ecsize = chlen;
chlen -= scno - cols_per_screen;
smp->c_eclen = chlen;
if (scno > cols_per_screen)
is_partial = 1;
}
smp->c_eboff = offset_in_line;
/* Terminate the loop. */
offset_in_line = len;
}
/*
* If the caller wants the cursor value, and this was the
* cursor character, set the value. There are two ways to
* put the cursor on a character -- if it's normal display
* mode, it goes on the last column of the character. If
* it's input mode, it goes on the first. In normal mode,
* set the cursor only if the entire character was displayed.
*/
if (cno_cnt &&
--cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {
*yp = smp - HMAP;
if (F_ISSET(sp, SC_TINPUT))
if (is_partial)
*xp = scno - smp->c_ecsize;
else
*xp = scno - chlen;
else
*xp = scno - 1;
if (O_ISSET(sp, O_NUMBER) &&
!F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)
*xp += O_NUMBER_LENGTH;
/* If the line is on the screen, quit. */
if (is_cached || no_draw)
goto ret1;
}
/* If the line is on the screen, don't display anything. */
if (is_cached || no_draw)
continue;
#define FLUSH { \
*cbp = '\0'; \
(void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \
cbp = cbuf; \
}
/*
* Display the character. We do tab expansion here because
* the screen interface doesn't have any way to set the tab
* length. Note, it's theoretically possible for chlen to
* be larger than cbuf, if the user set a impossibly large
* tabstop.
*/
if (is_tab)
while (chlen--) {
if (cbp >= ecbp)
FLUSH;
*cbp++ = TABCH;
}
else {
if (cbp + chlen >= ecbp)
FLUSH;
/* don't display half a wide character */
if (is_partial && CHAR_WIDTH(sp, ch) > 1) {
*cbp++ = ' ';
break;
}
/* XXXX this needs some rethinking */
if (INTISWIDE(ch)) {
/* Put a space before non-spacing char. */
if (CHAR_WIDTH(sp, ch) <= 0)
*cbp++ = L(' ');
*cbp++ = ch;
} else
for (kp = KEY_NAME(sp, ch) + offset_in_char;
chlen--;)
*cbp++ = (u_char)*kp++;
}
}
if (scno < cols_per_screen) {
/* If didn't paint the whole line, update the cache. */
smp->c_ecsize = smp->c_eclen = KEY_LEN(sp, ch);
smp->c_eboff = len - 1;
/*
* If not the info/mode line, and O_LIST set, and at the
* end of the line, and the line ended on this screen,
* add a trailing $.
*/
if (list_dollar) {
++scno;
chlen = KEY_LEN(sp, L('$'));
if (cbp + chlen >= ecbp)
FLUSH;
for (kp = KEY_NAME(sp, L('$')); chlen--;)
*cbp++ = *kp++;
}
/* If still didn't paint the whole line, clear the rest. */
if (scno < cols_per_screen)
(void)gp->scr_clrtoeol(sp);
}
/* Flush any buffered characters. */
if (cbp > cbuf)
FLUSH;
ret1: (void)gp->scr_move(sp, oldy, oldx);
return (0);
}
