void closure_str(msg_t *acc, closure_t *closure) {
msg_cat(acc, closure->name);
if (closure->arg_name_list != NULL) {
msg_t args_str = msg_new_from_str("(");
msg_list_str(&args_str, closure->arg_name_list);
msg_ncat(acc, args_str, (int)strlen(args_str) - 1);
msg_destroy(args_str);
msg_cat(acc, ")");
}
}
/*
* msg_cont --
* Return common continuation messages.
*
* PUBLIC: const char *msg_cmsg(SCR *, cmsg_t, size_t *);
*/
const char *
msg_cmsg(
SCR *sp,
cmsg_t which,
size_t *lenp)
{
switch (which) {
case CMSG_CONF:
return (msg_cat(sp, "268|confirm? [ynq]", lenp));
case CMSG_CONT:
return (msg_cat(sp, "269|Press any key to continue: ", lenp));
case CMSG_CONT_EX:
return (msg_cat(sp,
"270|Press any key to continue [: to enter more ex commands]: ",
lenp));
case CMSG_CONT_R:
return (msg_cat(sp, "161|Press Enter to continue: ", lenp));
case CMSG_CONT_S:
return (msg_cat(sp, "275| cont?", lenp));
case CMSG_CONT_Q:
return (msg_cat(sp,
"271|Press any key to continue [q to quit]: ", lenp));
default:
abort();
}
/* NOTREACHED */
}
/*
* 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;
}
/*
* mod_rpt --
* Report on the lines that changed.
*
* !!!
* Historic vi documentation (USD:15-8) claimed that "The editor will also
* always tell you when a change you make affects text which you cannot see."
* This wasn't true -- edit a large file and do "100d|1". We don't implement
* this semantic since it requires tracking each line that changes during a
* command instead of just keeping count.
*
* Line counts weren't right in historic vi, either. For example, given the
* file:
* abc
* def
* the command 2d}, from the 'b' would report that two lines were deleted,
* not one.
*
* PUBLIC: void mod_rpt(SCR *);
*/
void
mod_rpt(SCR *sp)
{
static char * const action[] = {
"293|added",
"294|changed",
"295|deleted",
"296|joined",
"297|moved",
"298|shifted",
"299|yanked",
};
static char * const lines[] = {
"300|line",
"301|lines",
};
recno_t total;
u_long rptval;
int first, cnt;
size_t blen, len, tlen;
const char *t;
char * const *ap;
char *bp, *p;
/* Change reports are turned off in batch mode. */
if (F_ISSET(sp, SC_EX_SILENT))
return;
/* Reset changing line number. */
sp->rptlchange = OOBLNO;
/*
* Don't build a message if not enough changed.
*
* !!!
* And now, a vi clone test. Historically, vi reported if the number
* of changed lines was > than the value, not >=, unless it was a yank
* command, which used >=. No lie. Furthermore, an action was never
* reported for a single line action. This is consistent for actions
* other than yank, but yank didn't report single line actions even if
* the report edit option was set to 1. In addition, setting report to
* 0 in the 4BSD historic vi was equivalent to setting it to 1, for an
* unknown reason (this bug was fixed in System III/V at some point).
* I got complaints, so nvi conforms to System III/V historic practice
* except that we report a yank of 1 line if report is set to 1.
*/
#define ARSIZE(a) sizeof(a) / sizeof (*a)
#define MAXNUM 25
rptval = O_VAL(sp, O_REPORT);
for (cnt = 0, total = 0; cnt < ARSIZE(action); ++cnt)
total += sp->rptlines[cnt];
if (total == 0)
return;
if (total <= rptval && sp->rptlines[L_YANKED] < rptval) {
for (cnt = 0; cnt < ARSIZE(action); ++cnt)
sp->rptlines[cnt] = 0;
return;
}
/* Build and display the message. */
GET_SPACE_GOTOC(sp, bp, blen, sizeof(action) * MAXNUM + 1);
for (p = bp, first = 1, tlen = 0,
ap = action, cnt = 0; cnt < ARSIZE(action); ++ap, ++cnt)
if (sp->rptlines[cnt] != 0) {
if (first)
first = 0;
else {
*p++ = ';';
*p++ = ' ';
tlen += 2;
}
len = snprintf(p, MAXNUM, "%lu ",
(u_long)sp->rptlines[cnt]);
p += len;
tlen += len;
t = msg_cat(sp,
lines[sp->rptlines[cnt] == 1 ? 0 : 1], &len);
memcpy(p, t, len);
p += len;
tlen += len;
*p++ = ' ';
++tlen;
t = msg_cat(sp, *ap, &len);
memcpy(p, t, len);
p += len;
tlen += len;
sp->rptlines[cnt] = 0;
}
/* Add trailing newline. */
*p = '\n';
++tlen;
(void)ex_fflush(sp);
sp->gp->scr_msg(sp, M_INFO, bp, tlen);
FREE_SPACE(sp, bp, blen);
alloc_err:
return;
#undef ARSIZE
#undef MAXNUM
}
/*
* 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;
}
/*
* ex_aci --
* Append, change, insert in ex.
*/
static int
ex_aci(SCR *sp, EXCMD *cmdp, enum which cmd)
{
CHAR_T *p, *t;
GS *gp;
TEXT *tp;
TEXTH tiq;
db_recno_t cnt, lno;
size_t len;
u_int32_t flags;
int need_newline;
gp = sp->gp;
NEEDFILE(sp, cmdp);
/*
* If doing a change, replace lines for as long as possible. Then,
* append more lines or delete remaining lines. Changes to an empty
* file are appends, inserts are the same as appends to the previous
* line.
*
* !!!
* Set the address to which we'll append. We set sp->lno to this
* address as well so that autoindent works correctly when get text
* from the user.
*/
lno = cmdp->addr1.lno;
sp->lno = lno;
if ((cmd == CHANGE || cmd == INSERT) && lno != 0)
--lno;
/*
* !!!
* If the file isn't empty, cut changes into the unnamed buffer.
*/
if (cmd == CHANGE && cmdp->addr1.lno != 0 &&
(cut(sp, NULL, &cmdp->addr1, &cmdp->addr2, CUT_LINEMODE) ||
del(sp, &cmdp->addr1, &cmdp->addr2, 1)))
return (1);
/*
* !!!
* Anything that was left after the command separator becomes part
* of the inserted text. Apparently, it was common usage to enter:
*
* :g/pattern/append|stuff1
*
* and append the line of text "stuff1" to the lines containing the
* pattern. It was also historically legal to enter:
*
* :append|stuff1
* stuff2
* .
*
* and the text on the ex command line would be appended as well as
* the text inserted after it. There was an historic bug however,
* that the user had to enter *two* terminating lines (the '.' lines)
* to terminate text input mode, in this case. This whole thing
* could be taken too far, however. Entering:
*
* :append|stuff1\
* stuff2
* stuff3
* .
*
* i.e. mixing and matching the forms confused the historic vi, and,
* not only did it take two terminating lines to terminate text input
* mode, but the trailing backslashes were retained on the input. We
* match historic practice except that we discard the backslashes.
*
* Input lines specified on the ex command line lines are separated by
* <newline>s. If there is a trailing delimiter an empty line was
* inserted. There may also be a leading delimiter, which is ignored
* unless it's also a trailing delimiter. It is possible to encounter
* a termination line, i.e. a single '.', in a global command, but not
* necessary if the text insert command was the last of the global
* commands.
*/
if (cmdp->save_cmdlen != 0) {
for (p = cmdp->save_cmd,
len = cmdp->save_cmdlen; len > 0; p = t) {
for (t = p; len > 0 && t[0] != '\n'; ++t, --len);
if (t != p || len == 0) {
if (F_ISSET(sp, SC_EX_GLOBAL) &&
t - p == 1 && p[0] == '.') {
++t;
if (len > 0)
--len;
break;
}
if (db_append(sp, 1, lno++, p, t - p))
return (1);
}
if (len != 0) {
++t;
if (--len == 0 &&
db_append(sp, 1, lno++, NULL, 0))
return (1);
}
}
/*
* If there's any remaining text, we're in a global, and
* there's more command to parse.
*
* !!!
* We depend on the fact that non-global commands will eat the
* rest of the command line as text input, and before getting
* any text input from the user. Otherwise, we'd have to save
* off the command text before or during the call to the text
* input function below.
*/
if (len != 0)
cmdp->save_cmd = t;
cmdp->save_cmdlen = len;
}
if (F_ISSET(sp, SC_EX_GLOBAL)) {
if ((sp->lno = lno) == 0 && db_exist(sp, 1))
sp->lno = 1;
return (0);
}
/*
* If not in a global command, read from the terminal.
*
* If this code is called by vi, we want to reset the terminal and use
* ex's line get routine. It actually works fine if we use vi's get
* routine, but it doesn't look as nice. Maybe if we had a separate
* window or something, but getting a line at a time looks awkward.
* However, depending on the screen that we're using, that may not
* be possible.
*/
if (F_ISSET(sp, SC_VI)) {
if (gp->scr_screen(sp, SC_EX)) {
ex_wemsg(sp, cmdp->cmd->name, EXM_NOCANON);
return (1);
}
/* If we're still in the vi screen, move out explicitly. */
need_newline = !F_ISSET(sp, SC_SCR_EXWROTE);
F_SET(sp, SC_SCR_EX | SC_SCR_EXWROTE);
if (need_newline)
(void)ex_puts(sp, "\n");
/*
* !!!
* Users of historical versions of vi sometimes get confused
* when they enter append mode, and can't seem to get out of
* it. Give them an informational message.
*/
(void)ex_puts(sp,
msg_cat(sp, "273|Entering ex input mode.", NULL));
(void)ex_puts(sp, "\n");
(void)ex_fflush(sp);
}
/*
* Set input flags; the ! flag turns off autoindent for append,
* change and insert.
*/
LF_INIT(TXT_DOTTERM | TXT_NUMBER);
if (!FL_ISSET(cmdp->iflags, E_C_FORCE) && O_ISSET(sp, O_AUTOINDENT))
LF_SET(TXT_AUTOINDENT);
if (O_ISSET(sp, O_BEAUTIFY))
LF_SET(TXT_BEAUTIFY);
/*
* This code can't use the common screen TEXTH structure (sp->tiq),
* as it may already be in use, e.g. ":append|s/abc/ABC/" would fail
* as we are only halfway through the text when the append code fires.
* Use a local structure instead. (The ex code would have to use a
* local structure except that we're guaranteed to finish remaining
* characters in the common TEXTH structure when they were inserted
* into the file, above.)
*/
memset(&tiq, 0, sizeof(TEXTH));
TAILQ_INIT(&tiq);
if (ex_txt(sp, &tiq, 0, flags))
return (1);
for (cnt = 0, tp = TAILQ_FIRST(&tiq); tp != NULL;
++cnt, tp = TAILQ_NEXT(tp, q))
if (db_append(sp, 1, lno++, tp->lb, tp->len))
return (1);
/*
* Set sp->lno to the final line number value (correcting for a
* possible 0 value) as that's historically correct for the final
* line value, whether or not the user entered any text.
*/
if ((sp->lno = lno) == 0 && db_exist(sp, 1))
sp->lno = 1;
return (0);
}
/*
* vs_busy --
* Display, update or clear a busy message.
*
* This routine is the default editor interface for vi busy messages. It
* implements a standard strategy of stealing lines from the bottom of the
* vi text screen. Screens using an alternate method of displaying busy
* messages, e.g. X11 clock icons, should set their scr_busy function to the
* correct function before calling the main editor routine.
*
* PUBLIC: void vs_busy __P((SCR *, const char *, busy_t));
*/
void
vs_busy(SCR *sp, const char *msg, busy_t btype)
{
GS *gp;
VI_PRIVATE *vip;
static const char flagc[] = "|/-\\";
struct timeval tv;
size_t len, notused;
const char *p;
/* Ex doesn't display busy messages. */
if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE))
return;
gp = sp->gp;
vip = VIP(sp);
/*
* Most of this routine is to deal with the screen sharing real estate
* between the normal edit messages and the busy messages. Logically,
* all that's needed is something that puts up a message, periodically
* updates it, and then goes away.
*/
switch (btype) {
case BUSY_ON:
++vip->busy_ref;
if (vip->totalcount != 0 || vip->busy_ref != 1)
break;
/* Initialize state for updates. */
vip->busy_ch = 0;
(void)gettimeofday(&vip->busy_tv, NULL);
/* Save the current cursor. */
(void)gp->scr_cursor(sp, &vip->busy_oldy, &vip->busy_oldx);
/* Display the busy message. */
p = msg_cat(sp, msg, &len);
(void)gp->scr_move(sp, LASTLINE(sp), 0);
(void)gp->scr_addstr(sp, p, len);
(void)gp->scr_cursor(sp, ¬used, &vip->busy_fx);
(void)gp->scr_clrtoeol(sp);
(void)gp->scr_move(sp, LASTLINE(sp), vip->busy_fx);
break;
case BUSY_OFF:
if (vip->busy_ref == 0)
break;
--vip->busy_ref;
/*
* If the line isn't in use for another purpose, clear it.
* Always return to the original position.
*/
if (vip->totalcount == 0 && vip->busy_ref == 0) {
(void)gp->scr_move(sp, LASTLINE(sp), 0);
(void)gp->scr_clrtoeol(sp);
}
(void)gp->scr_move(sp, vip->busy_oldy, vip->busy_oldx);
break;
case BUSY_UPDATE:
if (vip->totalcount != 0 || vip->busy_ref == 0)
break;
/* Update no more than every 1/8 of a second. */
(void)gettimeofday(&tv, NULL);
if (((tv.tv_sec - vip->busy_tv.tv_sec) * 1000000 +
(tv.tv_usec - vip->busy_tv.tv_usec)) < 125000)
return;
vip->busy_tv = tv;
/* Display the update. */
if (vip->busy_ch == sizeof(flagc) - 1)
vip->busy_ch = 0;
(void)gp->scr_move(sp, LASTLINE(sp), vip->busy_fx);
(void)gp->scr_addstr(sp, flagc + vip->busy_ch++, 1);
(void)gp->scr_move(sp, LASTLINE(sp), vip->busy_fx);
break;
}
(void)gp->scr_refresh(sp, 0);
}
/*
* file_write --
* Write the file to disk. Historic vi had fairly convoluted
* semantics for whether or not writes would happen. That's
* why all the flags.
*
* PUBLIC: int file_write __P((SCR *, MARK *, MARK *, char *, int));
*/
int
file_write(SCR *sp, MARK *fm, MARK *tm, char *name, int flags)
{
enum { NEWFILE, OLDFILE } mtype;
struct stat sb;
EXF *ep;
FILE *fp;
FREF *frp;
MARK from, to;
size_t len;
u_long nlno, nch;
int fd, nf, noname, oflags, rval;
char *p, *s, *t, buf[MAXPATHLEN + 64];
const char *msgstr;
ep = sp->ep;
frp = sp->frp;
/*
* Writing '%', or naming the current file explicitly, has the
* same semantics as writing without a name.
*/
if (name == NULL || !strcmp(name, frp->name)) {
noname = 1;
name = frp->name;
} else
noname = 0;
/* Can't write files marked read-only, unless forced. */
if (!LF_ISSET(FS_FORCE) && noname && O_ISSET(sp, O_READONLY)) {
msgq(sp, M_ERR, LF_ISSET(FS_POSSIBLE) ?
"244|Read-only file, not written; use ! to override" :
"245|Read-only file, not written");
return (1);
}
/* If not forced, not appending, and "writeany" not set ... */
if (!LF_ISSET(FS_FORCE | FS_APPEND) && !O_ISSET(sp, O_WRITEANY)) {
/* Don't overwrite anything but the original file. */
if ((!noname || F_ISSET(frp, FR_NAMECHANGE)) &&
!stat(name, &sb)) {
msgq_str(sp, M_ERR, name,
LF_ISSET(FS_POSSIBLE) ?
"246|%s exists, not written; use ! to override" :
"247|%s exists, not written");
return (1);
}
/*
* Don't write part of any existing file. Only test for the
* original file, the previous test catches anything else.
*/
if (!LF_ISSET(FS_ALL) && noname && !stat(name, &sb)) {
msgq(sp, M_ERR, LF_ISSET(FS_POSSIBLE) ?
"248|Partial file, not written; use ! to override" :
"249|Partial file, not written");
return (1);
}
}
/*
* Figure out if the file already exists -- if it doesn't, we display
* the "new file" message. The stat might not be necessary, but we
* just repeat it because it's easier than hacking the previous tests.
* The information is only used for the user message and modification
* time test, so we can ignore the obvious race condition.
*
* One final test. If we're not forcing or appending the current file,
* and we have a saved modification time, object if the file changed
* since we last edited or wrote it, and make them force it.
*/
if (stat(name, &sb))
mtype = NEWFILE;
else {
if (noname && !LF_ISSET(FS_FORCE | FS_APPEND) &&
((F_ISSET(ep, F_DEVSET) &&
(sb.st_dev != ep->mdev || sb.st_ino != ep->minode)) ||
sb.st_mtime != ep->mtime)) {
msgq_str(sp, M_ERR, name, LF_ISSET(FS_POSSIBLE) ?
"250|%s: file modified more recently than this copy; use ! to override" :
"251|%s: file modified more recently than this copy");
return (1);
}
mtype = OLDFILE;
}
/* Set flags to create, write, and either append or truncate. */
oflags = O_CREAT | O_WRONLY |
(LF_ISSET(FS_APPEND) ? O_APPEND : O_TRUNC);
/* Backup the file if requested. */
if (!opts_empty(sp, O_BACKUP, 1) &&
file_backup(sp, name, O_STR(sp, O_BACKUP)) && !LF_ISSET(FS_FORCE))
return (1);
/* Open the file. */
SIGBLOCK;
if ((fd = open(name, oflags,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) < 0) {
msgq_str(sp, M_SYSERR, name, "%s");
SIGUNBLOCK;
return (1);
}
SIGUNBLOCK;
/* Try and get a lock. */
if (!noname && file_lock(sp, NULL, NULL, fd, 0) == LOCK_UNAVAIL)
msgq_str(sp, M_ERR, name,
"252|%s: write lock was unavailable");
#if __linux__
/*
* XXX
* In libc 4.5.x, fdopen(fd, "w") clears the O_APPEND flag (if set).
* This bug is fixed in libc 4.6.x.
*
* This code works around this problem for libc 4.5.x users.
* Note that this code is harmless if you're using libc 4.6.x.
*/
if (LF_ISSET(FS_APPEND) && lseek(fd, (off_t)0, SEEK_END) < 0) {
msgq(sp, M_SYSERR, name);
return (1);
}
#endif
/*
* Use stdio for buffering.
*
* XXX
* SVR4.2 requires the fdopen mode exactly match the original open
* mode, i.e. you have to open with "a" if appending.
*/
if ((fp = fdopen(fd, LF_ISSET(FS_APPEND) ? "a" : "w")) == NULL) {
msgq_str(sp, M_SYSERR, name, "%s");
(void)close(fd);
return (1);
}
/* Build fake addresses, if necessary. */
if (fm == NULL) {
from.lno = 1;
from.cno = 0;
fm = &from;
if (db_last(sp, &to.lno))
return (1);
to.cno = 0;
tm = &to;
}
rval = ex_writefp(sp, name, fp, fm, tm, &nlno, &nch, 0);
/*
* Save the new last modification time -- even if the write fails
* we re-init the time. That way the user can clean up the disk
* and rewrite without having to force it.
*/
if (noname) {
if (stat(name, &sb))
time(&ep->mtime);
else {
F_SET(ep, F_DEVSET);
ep->mdev = sb.st_dev;
ep->minode = sb.st_ino;
ep->mtime = sb.st_mtime;
}
}
/*
* If the write failed, complain loudly. ex_writefp() has already
* complained about the actual error, reinforce it if data was lost.
*/
if (rval) {
if (!LF_ISSET(FS_APPEND))
msgq_str(sp, M_ERR, name,
"254|%s: WARNING: FILE TRUNCATED");
return (1);
}
/*
* Once we've actually written the file, it doesn't matter that the
* file name was changed -- if it was, we've already whacked it.
*/
F_CLR(frp, FR_NAMECHANGE);
/*
* If wrote the entire file, and it wasn't by appending it to a file,
* clear the modified bit. If the file was written to the original
* file name and the file is a temporary, set the "no exit" bit. This
* permits the user to write the file and use it in the context of the
* filesystem, but still keeps them from discarding their changes by
* exiting.
*/
if (LF_ISSET(FS_ALL) && !LF_ISSET(FS_APPEND)) {
F_CLR(ep, F_MODIFIED);
if (F_ISSET(frp, FR_TMPFILE)) {
if (noname)
F_SET(frp, FR_TMPEXIT);
else
F_CLR(frp, FR_TMPEXIT);
}
}
p = msg_print(sp, name, &nf);
switch (mtype) {
case NEWFILE:
msgstr = msg_cat(sp,
"256|%s: new file: %lu lines, %lu characters", NULL);
len = snprintf(buf, sizeof(buf), msgstr, p, nlno, nch);
break;
case OLDFILE:
msgstr = msg_cat(sp, LF_ISSET(FS_APPEND) ?
"315|%s: appended: %lu lines, %lu characters" :
"257|%s: %lu lines, %lu characters", NULL);
len = snprintf(buf, sizeof(buf), msgstr, p, nlno, nch);
break;
default:
abort();
}
/*
* 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. Unfortunately, the user has typed ahead, and chaos will
* result. If we assume that the characters in the filenames only take
* a single screen column each, we can trim the filename.
*/
s = buf;
if (len >= sp->cols) {
for (s = buf, t = buf + strlen(p); s < t &&
(*s != '/' || len >= sp->cols - 3); ++s, --len);
if (s == t)
s = buf;
else {
*--s = '.'; /* Leading ellipses. */
*--s = '.';
*--s = '.';
}
}
msgq(sp, M_INFO, s);
if (nf)
FREE_SPACE(sp, p, 0);
return (0);
}
/*
* ex_bang -- :[line [,line]] ! command
*
* Pass the rest of the line after the ! character to the program named by
* the O_SHELL option.
*
* Historical vi did NOT do shell expansion on the arguments before passing
* them, only file name expansion. This means that the O_SHELL program got
* "$t" as an argument if that is what the user entered. Also, there's a
* special expansion done for the bang command. Any exclamation points in
* the user's argument are replaced by the last, expanded ! command.
*
* There's some fairly amazing slop in this routine to make the different
* ways of getting here display the right things. It took a long time to
* get it right (wrong?), so be careful.
*
* PUBLIC: int ex_bang(SCR *, EXCMD *);
*/
int
ex_bang(SCR *sp, EXCMD *cmdp)
{
enum filtertype ftype;
ARGS *ap;
EX_PRIVATE *exp;
MARK rm;
recno_t lno;
int rval;
const char *msg;
char *np;
size_t nlen;
ap = cmdp->argv[0];
if (ap->len == 0) {
ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
return (1);
}
/* Set the "last bang command" remembered value. */
exp = EXP(sp);
free(exp->lastbcomm);
if ((exp->lastbcomm = v_wstrdup(sp, ap->bp, ap->len)) == NULL) {
msgq(sp, M_SYSERR, NULL);
return (1);
}
/*
* If the command was modified by the expansion, it was historically
* redisplayed.
*/
if (F_ISSET(cmdp, E_MODIFY) && !F_ISSET(sp, SC_EX_SILENT)) {
/*
* Display the command if modified. Historic ex/vi displayed
* the command if it was modified due to file name and/or bang
* expansion. If piping lines in vi, it would be immediately
* overwritten by any error or line change reporting.
*/
if (F_ISSET(sp, SC_VI))
vs_update(sp, "!", ap->bp);
else {
(void)ex_printf(sp, "!"WS"\n", ap->bp);
(void)ex_fflush(sp);
}
}
/*
* If no addresses were specified, run the command. If there's an
* underlying file, it's been modified and autowrite is set, write
* the file back. If the file has been modified, autowrite is not
* set and the warn option is set, tell the user about the file.
*/
if (cmdp->addrcnt == 0) {
msg = NULL;
if (sp->ep != NULL && F_ISSET(sp->ep, F_MODIFIED))
if (O_ISSET(sp, O_AUTOWRITE)) {
if (file_aw(sp, FS_ALL))
return (0);
} else if (O_ISSET(sp, O_WARN) &&
!F_ISSET(sp, SC_EX_SILENT))
msg = msg_cat(sp,
"303|File modified since last write.",
NULL);
/* If we're still in a vi screen, move out explicitly. */
INT2CHAR(sp, ap->bp, ap->len+1, np, nlen);
(void)ex_exec_proc(sp,
cmdp, np, msg, !F_ISSET(sp, SC_EX | SC_SCR_EXWROTE));
}
/*
* If addresses were specified, pipe lines from the file through the
* command.
*
* Historically, vi lines were replaced by both the stdout and stderr
* lines of the command, but ex lines by only the stdout lines. This
* makes no sense to me, so nvi makes it consistent for both, and
* matches vi's historic behavior.
*/
else {
NEEDFILE(sp, cmdp);
/* Autoprint is set historically, even if the command fails. */
F_SET(cmdp, E_AUTOPRINT);
/*
* !!!
* Historical vi permitted "!!" in an empty file. When this
* happens, we arrive here with two addresses of 1,1 and a
* bad attitude. The simple solution is to turn it into a
* FILTER_READ operation, with the exception that stdin isn't
* opened for the utility, and the cursor position isn't the
* same. The only historic glitch (I think) is that we don't
* put an empty line into the default cut buffer, as historic
* vi did. Imagine, if you can, my disappointment.
*/
ftype = FILTER_BANG;
if (cmdp->addr1.lno == 1 && cmdp->addr2.lno == 1) {
if (db_last(sp, &lno))
return (1);
if (lno == 0) {
cmdp->addr1.lno = cmdp->addr2.lno = 0;
ftype = FILTER_RBANG;
}
}
rval = ex_filter(sp, cmdp,
&cmdp->addr1, &cmdp->addr2, &rm, ap->bp, ftype);
/*
* If in vi mode, move to the first nonblank.
*
* !!!
* Historic vi wasn't consistent in this area -- if you used
* a forward motion it moved to the first nonblank, but if you
* did a backward motion it didn't. And, if you followed a
* backward motion with a forward motion, it wouldn't move to
* the nonblank for either. Going to the nonblank generally
* seems more useful and consistent, so we do it.
*/
sp->lno = rm.lno;
if (F_ISSET(sp, SC_VI)) {
sp->cno = 0;
(void)nonblank(sp, sp->lno, &sp->cno);
} else
sp->cno = rm.cno;
}
/* Ex terminates with a bang, even if the command fails. */
if (!F_ISSET(sp, SC_VI) && !F_ISSET(sp, SC_EX_SILENT))
(void)ex_puts(sp, "!\n");
/*
* XXX
* The ! commands never return an error, so that autoprint always
* happens in the ex parser.
*/
return (0);
}
