/*
* vs_screens --
* Return the screens necessary to display the line, or if specified,
* the physical character column within the line, including space
* required for the O_NUMBER and O_LIST options.
*
* PUBLIC: size_t vs_screens __P((SCR *, db_recno_t, size_t *));
*/
size_t
vs_screens(SCR *sp, db_recno_t lno, size_t *cnop)
{
size_t cols, screens;
/* Left-right screens are simple, it's always 1. */
if (O_ISSET(sp, O_LEFTRIGHT))
return (1);
/*
* Check for a cached value. We maintain a cache because, if the
* line is large, this routine gets called repeatedly. One other
* hack, lots of time the cursor is on column one, which is an easy
* one.
*/
if (cnop == NULL) {
if (VIP(sp)->ss_lno == lno)
return (VIP(sp)->ss_screens);
} else if (*cnop == 0)
return (1);
/* Figure out how many columns the line/column needs. */
cols = vs_columns(sp, NULL, lno, cnop, NULL);
screens = (cols / sp->cols + (cols % sp->cols ? 1 : 0));
if (screens == 0)
screens = 1;
/* Cache the value. */
if (cnop == NULL) {
VIP(sp)->ss_lno = lno;
VIP(sp)->ss_screens = screens;
}
return (screens);
}
/*
* v_chrrepeat -- [count],
* Repeat the last F, f, T or t search in the reverse direction.
*
* PUBLIC: int v_chrrepeat __P((SCR *, VICMD *));
*/
int
v_chrrepeat(SCR *sp, VICMD *vp)
{
cdir_t savedir;
int rval;
vp->character = VIP(sp)->lastckey;
savedir = VIP(sp)->csearchdir;
switch (VIP(sp)->csearchdir) {
case CNOTSET:
noprev(sp);
return (1);
case FSEARCH:
rval = v_chf(sp, vp);
break;
case fSEARCH:
rval = v_chF(sp, vp);
break;
case TSEARCH:
rval = v_cht(sp, vp);
break;
case tSEARCH:
rval = v_chT(sp, vp);
break;
default:
abort();
}
VIP(sp)->csearchdir = savedir;
return (rval);
}
/*
* v_chF -- [count]Fc
* Search backward in the line for the next occurrence of the
* specified character.
*
* PUBLIC: int v_chF __P((SCR *, VICMD *));
*/
int
v_chF(SCR *sp, VICMD *vp)
{
size_t len;
u_long cnt;
int isempty;
ARG_CHAR_T key;
CHAR_T *endp, *p;
/*
* !!!
* If it's a dot command, it doesn't reset the key for which
* we're searching, e.g. in "df1|f2|.|;", the ';' searches
* for a '2'.
*/
key = vp->character;
if (!F_ISSET(vp, VC_ISDOT))
VIP(sp)->lastckey = key;
VIP(sp)->csearchdir = FSEARCH;
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (isempty)
goto empty;
return (1);
}
if (len == 0) {
empty: notfound(sp, key);
return (1);
}
endp = p - 1;
p += vp->m_start.cno;
for (cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1; cnt--;) {
while (--p > endp && *p != key);
if (p == endp) {
notfound(sp, key);
return (1);
}
}
vp->m_stop.cno = (p - endp) - 1;
/*
* All commands move to the end of the range. Motion commands
* adjust the starting point to the character before the current
* one.
*/
vp->m_final = vp->m_stop;
if (ISMOTION(vp))
--vp->m_start.cno;
return (0);
}
/*
* v_tag --
* Tag command.
*/
static int
v_tag(SCR *sp, VICMD *vp)
{
EXCMD cmd;
if (v_curword(sp))
return (1);
ex_cinit(sp, &cmd, C_TAG, 0, OOBLNO, OOBLNO, 0);
argv_exp0(sp, &cmd, VIP(sp)->keyw, STRLEN(VIP(sp)->keyw));
return (v_exec_ex(sp, vp, &cmd));
}
/*
* v_chf -- [count]fc
* Search forward in the line for the next occurrence of the
* specified character.
*
* PUBLIC: int v_chf __P((SCR *, VICMD *));
*/
int
v_chf(SCR *sp, VICMD *vp)
{
size_t len;
u_long cnt;
int isempty;
ARG_CHAR_T key;
CHAR_T *endp, *p, *startp;
/*
* !!!
* If it's a dot command, it doesn't reset the key for which we're
* searching, e.g. in "df1|f2|.|;", the ';' searches for a '2'.
*/
key = vp->character;
if (!F_ISSET(vp, VC_ISDOT))
VIP(sp)->lastckey = key;
VIP(sp)->csearchdir = fSEARCH;
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (isempty)
goto empty;
return (1);
}
if (len == 0) {
empty: notfound(sp, key);
return (1);
}
endp = (startp = p) + len;
p += vp->m_start.cno;
for (cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1; cnt--;) {
while (++p < endp && *p != key);
if (p == endp) {
notfound(sp, key);
return (1);
}
}
vp->m_stop.cno = p - startp;
/*
* Non-motion commands move to the end of the range.
* Delete and yank stay at the start, ignore others.
*/
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
return (0);
}
/*
* vs_scroll --
* Scroll the screen for output.
*/
static void
vs_scroll(SCR *sp, int *continuep, sw_t wtype)
{
GS *gp;
VI_PRIVATE *vip;
gp = sp->gp;
vip = VIP(sp);
if (!IS_ONELINE(sp)) {
/*
* Scroll the screen. Instead of scrolling the entire screen,
* delete the line above the first line output so preserve the
* maximum amount of the screen.
*/
(void)gp->scr_move(sp, vip->totalcount <
sp->rows ? LASTLINE(sp) - vip->totalcount : 0, 0);
(void)gp->scr_deleteln(sp);
/* If there are screens below us, push them back into place. */
if (sp->q.cqe_next != (void *)&sp->wp->scrq) {
(void)gp->scr_move(sp, LASTLINE(sp), 0);
(void)gp->scr_insertln(sp);
}
}
if (wtype == SCROLL_W_QUIT && vip->linecount < sp->t_maxrows)
return;
vs_wait(sp, continuep, wtype);
}
void VIP_ShowRights(gedict_t* cl)
{
int flags = VIP( cl );
char *rights = "";
if ( !flags )
return;
if ( flags & VIP_NORMAL ) {
flags &= ~VIP_NORMAL;
rights = va("%s normal", rights);
}
if ( flags & VIP_NOTKICKABLE ) {
flags &= ~VIP_NOTKICKABLE;
rights = va("%s not_kick", rights);
}
if ( flags & VIP_ADMIN ) {
flags &= ~VIP_ADMIN;
rights = va("%s admin", rights);
}
if ( flags & VIP_RCON ) {
flags &= ~VIP_RCON;
rights = va("%s rcon_adm", rights);
}
if ( strnull( rights ) || flags )
rights = va("%s UNKNOWN", rights);
G_sprint(cl, 2, "You are a VIP with rights:%s\n", rights);
}
/*
* v_screen_copy --
* Copy vi screen.
*
* PUBLIC: int v_screen_copy __P((SCR *, SCR *));
*/
int
v_screen_copy(SCR *orig, SCR *sp)
{
VI_PRIVATE *ovip, *nvip;
/* Create the private vi structure. */
CALLOC_RET(orig, nvip, VI_PRIVATE *, 1, sizeof(VI_PRIVATE));
sp->vi_private = nvip;
/* Invalidate the line size cache. */
VI_SCR_CFLUSH(nvip);
if (orig == NULL) {
nvip->csearchdir = CNOTSET;
} else {
ovip = VIP(orig);
/* User can replay the last input, but nothing else. */
if (ovip->rep_len != 0) {
MALLOC_RET(orig, nvip->rep, EVENT *, ovip->rep_len);
memmove(nvip->rep, ovip->rep, ovip->rep_len);
nvip->rep_len = ovip->rep_len;
}
/* Copy the paragraph/section information. */
if (ovip->ps != NULL && (nvip->ps =
v_strdup(sp, ovip->ps, strlen(ovip->ps))) == NULL)
return (1);
nvip->lastckey = ovip->lastckey;
nvip->csearchdir = ovip->csearchdir;
nvip->srows = ovip->srows;
}
/*
* !!!
* Historical whackadoo. The dot command `puts' the numbered buffer
* after the last one put. For example, `"4p.' would put buffer #4
* and buffer #5. If the user continued to enter '.', the #9 buffer
* would be repeatedly output. This was not documented, and is a bit
* tricky to reconstruct. Historical versions of vi also dropped the
* contents of the default buffer after each put, so after `"4p' the
* default buffer would be empty. This makes no sense to me, so we
* don't bother. Don't assume sequential order of numeric characters.
*
* And, if that weren't exciting enough, failed commands don't normally
* set the dot command. Well, boys and girls, an exception is that
* the buffer increment gets done regardless of the success of the put.
*/
static void
inc_buf(SCR *sp, VICMD *vp)
{
CHAR_T v;
switch (vp->buffer) {
case '1':
v = '2';
break;
case '2':
v = '3';
break;
case '3':
v = '4';
break;
case '4':
v = '5';
break;
case '5':
v = '6';
break;
case '6':
v = '7';
break;
case '7':
v = '8';
break;
case '8':
v = '9';
break;
default:
return;
}
VIP(sp)->sdot.buffer = vp->buffer = v;
}
/*
* vs_column --
* Return the logical column of the cursor in the line.
*
* PUBLIC: int vs_column __P((SCR *, size_t *));
*/
int
vs_column(SCR *sp, size_t *colp)
{
VI_PRIVATE *vip;
vip = VIP(sp);
*colp = (O_ISSET(sp, O_LEFTRIGHT) ?
vip->sc_smap->coff : (vip->sc_smap->soff - 1) * sp->cols) +
vip->sc_col - (O_ISSET(sp, O_NUMBER) ? O_NUMBER_LENGTH : 0);
return (0);
}
/*
* v_curword --
* Get the word (tagstring, actually) the cursor is on.
*
* PUBLIC: int v_curword __P((SCR *));
*/
int
v_curword(SCR *sp)
{
VI_PRIVATE *vip;
size_t beg, end, len;
int moved;
CHAR_T *p;
if (db_get(sp, sp->lno, DBG_FATAL, &p, &len))
return (1);
/*
* !!!
* Historically, tag commands skipped over any leading whitespace
* characters. Make this true in general when using cursor words.
* If movement, getting a cursor word implies moving the cursor to
* its beginning. Refresh now.
*
* !!!
* Find the beginning/end of the keyword. Keywords are currently
* used for cursor-word searching and for tags. Historical vi
* only used the word in a tag search from the cursor to the end
* of the word, i.e. if the cursor was on the 'b' in " abc ", the
* tag was "bc". For consistency, we make cursor word searches
* follow the same rule.
*/
for (moved = 0,
beg = sp->cno; beg < len && ISSPACE(p[beg]); moved = 1, ++beg);
if (beg >= len) {
msgq(sp, M_BERR, "212|Cursor not in a word");
return (1);
}
if (moved) {
sp->cno = beg;
(void)vs_refresh(sp, 0);
}
/*
* Find the end of the word.
*
* !!!
* Historically, vi accepted any non-blank as initial character
* when building up a tagstring. Required by IEEE 1003.1-2001.
*/
for (end = beg; ++end < len && inword(p[end]););
vip = VIP(sp);
vip->klen = len = (end - beg);
BINC_RETW(sp, vip->keyw, vip->keywlen, len+1);
MEMMOVE(vip->keyw, p + beg, len);
vip->keyw[len] = '\0'; /* XXX */
return (0);
}
/*
* v_chrepeat -- [count];
* Repeat the last F, f, T or t search.
*
* PUBLIC: int v_chrepeat __P((SCR *, VICMD *));
*/
int
v_chrepeat(SCR *sp, VICMD *vp)
{
vp->character = VIP(sp)->lastckey;
switch (VIP(sp)->csearchdir) {
case CNOTSET:
noprev(sp);
return (1);
case FSEARCH:
return (v_chF(sp, vp));
case fSEARCH:
return (v_chf(sp, vp));
case TSEARCH:
return (v_chT(sp, vp));
case tSEARCH:
return (v_cht(sp, vp));
default:
abort();
}
/* NOTREACHED */
}
qbool nospecs_canconnect( gedict_t *spec )
{
if ( cvar("_k_nospecs") )
{
// some VIPS able to connect anyway
if ( !( VIP( spec ) & ALLOWED_NOSPECS_VIPS ) )
{
return false;
}
}
return true;
}
/*
* v_searchw -- [count]^A
* Search for the word under the cursor.
*
* PUBLIC: int v_searchw __P((SCR *, VICMD *));
*/
int
v_searchw(SCR *sp, VICMD *vp)
{
size_t blen, len;
int rval;
CHAR_T *bp, *p;
len = VIP(sp)->klen + MAX(RE_WSTART_LEN, 1)
+ MAX(RE_WSTOP_LEN, RE_NWSTOP_LEN);
GET_SPACE_RETW(sp, bp, blen, len);
p = bp;
/* Only the first character can be non-word, see v_curword. */
if (inword(VIP(sp)->keyw[0]))
p = MEMPCPY(p, RE_WSTART, RE_WSTART_LEN);
else if (is_especial(VIP(sp)->keyw[0]))
p = MEMPCPY(p, L("\\"), 1);
p = MEMPCPY(p, VIP(sp)->keyw, VIP(sp)->klen);
if (inword(p[-1]))
p = MEMPCPY(p, RE_WSTOP, RE_WSTOP_LEN);
else
/*
* The keyword is a single non-word character.
* We want it to stay the same when typing ^A several times
* in a row, just the way the other cases behave.
*/
p = MEMPCPY(p, RE_NWSTOP, RE_NWSTOP_LEN);
len = p - bp;
rval = v_search(sp, vp, bp, len, SEARCH_SET | SEARCH_EXTEND, FORWARD);
FREE_SPACEW(sp, bp, blen);
return (rval);
}
/*
* v_chT -- [count]Tc
* Search backward in the line for the character after the next
* occurrence of the specified character.
*
* PUBLIC: int v_chT __P((SCR *, VICMD *));
*/
int
v_chT(SCR *sp, VICMD *vp)
{
if (v_chF(sp, vp))
return (1);
/*
* v_chF places the cursor on the character, where the 'T'
* command wants it to its right. We know this is safe since
* we had to move left for v_chF() to have succeeded.
*/
++vp->m_stop.cno;
vp->m_final = vp->m_stop;
VIP(sp)->csearchdir = TSEARCH;
return (0);
}
/*
* v_sel_start --
* Start selection.
*/
static int
v_sel_start(SCR *sp, EVENT *evp)
{
SMAP *smp;
VI_PRIVATE *vip;
smp = HMAP + evp->e_lno;
if (smp > TMAP) {
/* XXX */
return (1);
}
vip = VIP(sp);
vip->sel.lno = smp->lno;
vip->sel.cno =
vs_colpos(sp, smp->lno, evp->e_cno + (smp->soff - 1) * sp->cols);
return (0);
}
/*
* v_buildmcs --
* Build the match character list.
*
* PUBLIC: int v_buildmcs(SCR *, char *);
*/
int
v_buildmcs(SCR *sp, char *str)
{
CHAR_T **mp = &VIP(sp)->mcs;
size_t len = strlen(str) + 1;
free(*mp);
MALLOC(sp, *mp, len * sizeof(CHAR_T));
if (*mp == NULL)
return (1);
#ifdef USE_WIDECHAR
if (mbstowcs(*mp, str, len) == (size_t)-1)
return (1);
#else
memcpy(*mp, str, len);
#endif
return (0);
}
void vote_check_nospecs ()
{
int veto;
if ( match_in_progress || intermission_running || match_over )
return;
if ( !get_votes( OV_NOSPECS ) )
return;
veto = is_admins_vote( OV_NOSPECS );
if( veto || !get_votes_req( OV_NOSPECS, true ) )
{
vote_clear( OV_NOSPECS );
// set no specs mode
cvar_fset("_k_nospecs", !cvar("_k_nospecs"));
if ( veto )
G_bprint(2, "%s\n", redtext(va("No spectators mode %s by admin veto", OnOff(cvar("_k_nospecs")))));
else
G_bprint(2, "%s\n", redtext(va("No spectators mode %s by majority vote", OnOff(cvar("_k_nospecs")))));
// kick specs
if ( cvar("_k_nospecs") )
{
gedict_t *spec;
for ( spec = world; (spec = find_spc( spec )); )
{
if ( VIP( spec ) & ALLOWED_NOSPECS_VIPS )
continue; // don't kick this VIP
if ( is_real_adm(spec) )
continue; // don't kick real admin
stuffcmd(spec, "disconnect\n"); // FIXME: stupid way
}
}
return;
}
}
/*
* v_screen_end --
* End a vi screen.
*
* PUBLIC: int v_screen_end(SCR *);
*/
int
v_screen_end(SCR *sp)
{
VI_PRIVATE *vip;
if ((vip = VIP(sp)) == NULL)
return (0);
free(vip->keyw);
free(vip->rep);
free(vip->mcs);
free(vip->ps);
free(HMAP);
free(vip);
sp->vi_private = NULL;
return (0);
}
/*
* v_c_settop --
* Scrollbar position.
*/
static int
v_c_settop(SCR *sp, VICMD *vp)
{
SMAP *smp;
size_t x = 0, y = LASTLINE(sp); /* Future: change to -1 to not
* display the cursor
*/
size_t tx, ty = -1;
/*
* We want to scroll the screen, without changing the cursor position.
* So, we fill the screen map and then flush it to the screen. Then,
* set the VIP_S_REFRESH flag so the main vi loop doesn't update the
* screen. When the next real command happens, the refresh code will
* notice that the screen map is way wrong and fix it.
*
* XXX
* There may be a serious performance problem here -- we're doing no
* optimization whatsoever, which means that we're copying the entire
* screen out to the X11 screen code on each change.
*/
if (vs_sm_fill(sp, vp->ev.e_lno, P_TOP))
return (1);
for (smp = HMAP; smp <= TMAP; ++smp) {
SMAP_FLUSH(smp);
if (vs_line(sp, smp, &ty, &tx))
return (1);
if (ty != (size_t)-1) {
y = ty;
x = tx;
}
}
(void)sp->gp->scr_move(sp, y, x);
F_SET(VIP(sp), VIP_S_REFRESH);
return (sp->gp->scr_refresh(sp, 0));
}
/*
* v_cht -- [count]tc
* Search forward in the line for the character before the next
* occurrence of the specified character.
*
* PUBLIC: int v_cht __P((SCR *, VICMD *));
*/
int
v_cht(SCR *sp, VICMD *vp)
{
if (v_chf(sp, vp))
return (1);
/*
* v_chf places the cursor on the character, where the 't'
* command wants it to its left. We know this is safe since
* we had to move right for v_chf() to have succeeded.
*/
--vp->m_stop.cno;
/*
* Make any necessary correction to the motion decision made
* by the v_chf routine.
*/
if (!ISMOTION(vp))
vp->m_final = vp->m_stop;
VIP(sp)->csearchdir = tSEARCH;
return (0);
}
/*
* v_searchw -- [count]^A
* Search for the word under the cursor.
*
* PUBLIC: int v_searchw __P((SCR *, VICMD *));
*/
int
v_searchw(SCR *sp, VICMD *vp)
{
size_t blen, len;
int rval;
CHAR_T *bp, *p;
/* An upper bound for the SIZE of the RE under construction. */
len = VIP(sp)->klen + MAX(RE_WSTART_LEN, 1)
+ MAX(RE_WSTOP_LEN, RE_NWSTOP_LEN);
GET_SPACE_RETW(sp, bp, blen, len);
p = bp;
/* Only the first character can be non-word, see v_curword. */
if (inword(VIP(sp)->keyw[0])) {
MEMCPY(p, RE_WSTART, RE_WSTART_LEN);
p += RE_WSTART_LEN;
} else if (is_special(VIP(sp)->keyw[0])) {
MEMCPY(p, L("\\"), 1);
p += 1;
}
MEMCPY(p, VIP(sp)->keyw, VIP(sp)->klen);
p += VIP(sp)->klen;
if (inword(p[-1])) {
MEMCPY(p, RE_WSTOP, RE_WSTOP_LEN);
p += RE_WSTOP_LEN;
} else {
/*
* The keyword is a single non-word character.
* We want it to stay the same when typing ^A several times
* in a row, just the way the other cases behave.
*/
MEMCPY(p, RE_NWSTOP, RE_NWSTOP_LEN);
p += RE_NWSTOP_LEN;
}
len = p - bp;
rval = v_search(sp, vp, bp, len, SEARCH_SET, FORWARD);
FREE_SPACEW(sp, bp, blen);
return (rval);
}
/*
* vs_resolve --
* Deal with message output.
*
* PUBLIC: int vs_resolve __P((SCR *, SCR *, int));
*/
int
vs_resolve(SCR *sp, SCR *csp, int forcewait)
{
EVENT ev;
GS *gp;
WIN *wp;
MSGS *mp;
VI_PRIVATE *vip;
size_t oldy, oldx;
int redraw;
/*
* Vs_resolve is called from the main vi loop and the refresh function
* to periodically ensure that the user has seen any messages that have
* been displayed and that any status lines are correct. The sp screen
* is the screen we're checking, usually the current screen. When it's
* not, csp is the current screen, used for final cursor positioning.
*/
gp = sp->gp;
wp = sp->wp;
vip = VIP(sp);
if (csp == NULL)
csp = sp;
/* Save the cursor position. */
(void)gp->scr_cursor(csp, &oldy, &oldx);
/* Ring the bell if it's scheduled. */
if (F_ISSET(gp, G_BELLSCHED)) {
F_CLR(gp, G_BELLSCHED);
(void)gp->scr_bell(sp);
}
/* Display new file status line. */
if (F_ISSET(sp, SC_STATUS)) {
F_CLR(sp, SC_STATUS);
msgq_status(sp, sp->lno, MSTAT_TRUNCATE);
}
/* Report on line modifications. */
mod_rpt(sp);
/*
* Flush any saved messages. If the screen isn't ready, refresh
* it. (A side-effect of screen refresh is that we can display
* messages.) Once this is done, don't trust the cursor. That
* extra refresh screwed the pooch.
*/
if (gp->msgq.lh_first != NULL) {
if (!F_ISSET(sp, SC_SCR_VI) && vs_refresh(sp, 1))
return (1);
while ((mp = gp->msgq.lh_first) != NULL) {
wp->scr_msg(sp, mp->mtype, mp->buf, mp->len);
LIST_REMOVE(mp, q);
free(mp->buf);
free(mp);
}
F_SET(vip, VIP_CUR_INVALID);
}
switch (vip->totalcount) {
case 0:
redraw = 0;
break;
case 1:
/*
* If we're switching screens, we have to wait for messages,
* regardless. If we don't wait, skip updating the modeline.
*/
if (forcewait)
vs_scroll(sp, NULL, SCROLL_W);
else
F_SET(vip, VIP_S_MODELINE);
redraw = 0;
break;
default:
/*
* If >1 message line in use, prompt the user to continue and
* repaint overwritten lines.
*/
vs_scroll(sp, NULL, SCROLL_W);
ev.e_event = E_REPAINT;
ev.e_flno = vip->totalcount >=
sp->rows ? 1 : sp->rows - vip->totalcount;
ev.e_tlno = sp->rows;
redraw = 1;
break;
}
/* Reset the count of overwriting lines. */
vip->linecount = vip->lcontinue = vip->totalcount = 0;
/* Redraw. */
if (redraw)
(void)v_erepaint(sp, &ev);
/* Restore the cursor position. */
(void)gp->scr_move(csp, oldy, oldx);
return (0);
}
/*
* 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);
}
/*
* vs_ex_resolve --
* Deal with ex message output.
*
* This routine is called when exiting a colon command to resolve any ex
* output that may have occurred.
*
* PUBLIC: int vs_ex_resolve __P((SCR *, int *));
*/
int
vs_ex_resolve(SCR *sp, int *continuep)
{
EVENT ev;
GS *gp;
VI_PRIVATE *vip;
sw_t wtype;
gp = sp->gp;
vip = VIP(sp);
*continuep = 0;
/* If we ran any ex command, we can't trust the cursor position. */
F_SET(vip, VIP_CUR_INVALID);
/* Terminate any partially written message. */
if (vip->lcontinue != 0) {
vs_output(sp, vip->mtype, ".", 1);
vip->lcontinue = 0;
vip->mtype = M_NONE;
}
/*
* If we switched out of the vi screen into ex, switch back while we
* figure out what to do with the screen and potentially get another
* command to execute.
*
* If we didn't switch into ex, we're not required to wait, and less
* than 2 lines of output, we can continue without waiting for the
* wait.
*
* Note, all other code paths require waiting, so we leave the report
* of modified lines until later, so that we won't wait for no other
* reason than a threshold number of lines were modified. This means
* we display cumulative line modification reports for groups of ex
* commands. That seems right to me (well, at least not wrong).
*/
if (F_ISSET(sp, SC_SCR_EXWROTE)) {
if (sp->gp->scr_screen(sp, SC_VI))
return (1);
} else
if (!F_ISSET(sp, SC_EX_WAIT_YES) && vip->totalcount < 2) {
F_CLR(sp, SC_EX_WAIT_NO);
return (0);
}
/* Clear the required wait flag, it's no longer needed. */
F_CLR(sp, SC_EX_WAIT_YES);
/*
* Wait, unless explicitly told not to wait or the user interrupted
* the command. If the user is leaving the screen, for any reason,
* they can't continue with further ex commands.
*/
if (!F_ISSET(sp, SC_EX_WAIT_NO) && !INTERRUPTED(sp)) {
wtype = F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE |
SC_FSWITCH | SC_SSWITCH) ? SCROLL_W : SCROLL_W_EX;
if (F_ISSET(sp, SC_SCR_EXWROTE))
vs_wait(sp, continuep, wtype);
else
vs_scroll(sp, continuep, wtype);
if (*continuep)
return (0);
}
/* If ex wrote on the screen, refresh the screen image. */
if (F_ISSET(sp, SC_SCR_EXWROTE))
F_SET(vip, VIP_N_EX_PAINT);
/*
* If we're not the bottom of the split screen stack, the screen
* image itself is wrong, so redraw everything.
*/
if (sp->q.cqe_next != (void *)&sp->wp->scrq)
F_SET(sp, SC_SCR_REDRAW);
/* If ex changed the underlying file, the map itself is wrong. */
if (F_ISSET(vip, VIP_N_EX_REDRAW))
F_SET(sp, SC_SCR_REFORMAT);
/* Ex may have switched out of the alternate screen, return. */
(void)gp->scr_attr(sp, SA_ALTERNATE, 1);
/*
* Whew. We're finally back home, after what feels like years.
* Kiss the ground.
*/
F_CLR(sp, SC_SCR_EXWROTE | SC_EX_WAIT_NO);
/*
* We may need to repaint some of the screen, e.g.:
*
* :set
* :!ls
*
* gives us a combination of some lines that are "wrong", and a need
* for a full refresh.
*/
if (vip->totalcount > 1) {
/* Set up the redraw of the overwritten lines. */
ev.e_event = E_REPAINT;
ev.e_flno = vip->totalcount >=
sp->rows ? 1 : sp->rows - vip->totalcount;
ev.e_tlno = sp->rows;
/* Reset the count of overwriting lines. */
vip->linecount = vip->lcontinue = vip->totalcount = 0;
/* Redraw. */
(void)v_erepaint(sp, &ev);
} else
/* Reset the count of overwriting lines. */
vip->linecount = vip->lcontinue = vip->totalcount = 0;
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);
}
/*
* v_replace -- [count]r<char>
*
* !!!
* The r command in historic vi was almost beautiful in its badness. For
* example, "r<erase>" and "r<word erase>" beeped the terminal and deleted
* a single character. "Nr<carriage return>", where N was greater than 1,
* inserted a single carriage return. "r<escape>" did cancel the command,
* but "r<literal><escape>" erased a single character. To enter a literal
* <literal> character, it required three <literal> characters after the
* command. This may not be right, but at least it's not insane.
*
* PUBLIC: int v_replace __P((SCR *, VICMD *));
*/
int
v_replace(SCR *sp, VICMD *vp)
{
EVENT ev;
VI_PRIVATE *vip;
TEXT *tp;
size_t blen, len;
u_long cnt;
int quote, rval;
CHAR_T *bp;
CHAR_T *p;
vip = VIP(sp);
/*
* If the line doesn't exist, or it's empty, replacement isn't
* allowed. It's not hard to implement, but:
*
* 1: It's historic practice (vi beeped before the replacement
* character was even entered).
* 2: For consistency, this change would require that the more
* general case, "Nr", when the user is < N characters from
* the end of the line, also work, which would be a bit odd.
* 3: Replacing with a <newline> has somewhat odd semantics.
*/
if (db_get(sp, vp->m_start.lno, DBG_FATAL, &p, &len))
return (1);
if (len == 0) {
msgq(sp, M_BERR, "186|No characters to replace");
return (1);
}
/*
* Figure out how many characters to be replace. For no particular
* reason (other than that the semantics of replacing the newline
* are confusing) only permit the replacement of the characters in
* the current line. I suppose we could append replacement characters
* to the line, but I see no compelling reason to do so. Check this
* before we get the character to match historic practice, where Nr
* failed immediately if there were less than N characters from the
* cursor to the end of the line.
*/
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
vp->m_stop.lno = vp->m_start.lno;
vp->m_stop.cno = vp->m_start.cno + cnt - 1;
if (vp->m_stop.cno > len - 1) {
v_eol(sp, &vp->m_start);
return (1);
}
/*
* If it's not a repeat, reset the current mode and get a replacement
* character.
*/
quote = 0;
if (!F_ISSET(vp, VC_ISDOT)) {
sp->showmode = SM_REPLACE;
if (vs_refresh(sp, 0))
return (1);
next: if (v_event_get(sp, &ev, 0, 0))
return (1);
switch (ev.e_event) {
case E_CHARACTER:
/*
* <literal_next> means escape the next character.
* <escape> means they changed their minds.
*/
if (!quote) {
if (ev.e_value == K_VLNEXT) {
quote = 1;
goto next;
}
if (ev.e_value == K_ESCAPE)
return (0);
}
vip->rlast = ev.e_c;
vip->rvalue = ev.e_value;
break;
case E_ERR:
case E_EOF:
F_SET(sp, SC_EXIT_FORCE);
return (1);
case E_INTERRUPT:
/* <interrupt> means they changed their minds. */
return (0);
case E_WRESIZE:
/* <resize> interrupts the input mode. */
v_emsg(sp, NULL, VIM_WRESIZE);
return (0);
case E_REPAINT:
if (vs_repaint(sp, &ev))
return (1);
goto next;
default:
v_event_err(sp, &ev);
return (0);
}
}
/* Copy the line. */
GET_SPACE_RETW(sp, bp, blen, len);
MEMMOVE(bp, p, len);
p = bp;
/*
* Versions of nvi before 1.57 created N new lines when they replaced
* N characters with <carriage-return> or <newline> characters. This
* is different from the historic vi, which replaced N characters with
* a single new line. Users complained, so we match historic practice.
*/
if ((!quote && vip->rvalue == K_CR) || vip->rvalue == K_NL) {
/* Set return line. */
vp->m_stop.lno = vp->m_start.lno + 1;
vp->m_stop.cno = 0;
/* The first part of the current line. */
if (db_set(sp, vp->m_start.lno, p, vp->m_start.cno))
goto err_ret;
/*
* The rest of the current line. And, of course, now it gets
* tricky. If there are characters left in the line and if
* the autoindent edit option is set, white space after the
* replaced character is discarded, autoindent is applied, and
* the cursor moves to the last indent character.
*/
p += vp->m_start.cno + cnt;
len -= vp->m_start.cno + cnt;
if (len != 0 && O_ISSET(sp, O_AUTOINDENT))
for (; len && isblank(*p); --len, ++p);
if ((tp = text_init(sp, p, len, len)) == NULL)
goto err_ret;
if (len != 0 && O_ISSET(sp, O_AUTOINDENT)) {
if (v_txt_auto(sp, vp->m_start.lno, NULL, 0, tp))
goto err_ret;
vp->m_stop.cno = tp->ai ? tp->ai - 1 : 0;
} else
vp->m_stop.cno = 0;
vp->m_stop.cno = tp->ai ? tp->ai - 1 : 0;
if (db_append(sp, 1, vp->m_start.lno, tp->lb, tp->len))
err_ret: rval = 1;
else {
text_free(tp);
rval = 0;
}
} else {
STRSET(bp + vp->m_start.cno, vip->rlast, cnt);
rval = db_set(sp, vp->m_start.lno, bp, len);
}
FREE_SPACEW(sp, bp, blen);
vp->m_final = vp->m_stop;
return (rval);
}
/*
* v_match -- %
* Search to matching character.
*
* PUBLIC: int v_match(SCR *, VICMD *);
*/
int
v_match(SCR *sp, VICMD *vp)
{
VCS cs;
MARK *mp;
size_t cno, len, off;
int cnt, isempty, matchc, startc, (*gc)(SCR *, VCS *);
CHAR_T *p;
CHAR_T *cp;
const CHAR_T *match_chars;
/*
* Historically vi would match (), {} and [] however
* an update included <>. This is ok for editing HTML
* but a pain in the butt for C source.
* Making it an option lets the user decide what is 'right'.
*/
match_chars = VIP(sp)->mcs;
/*
* !!!
* Historic practice; ignore the count.
*
* !!!
* Historical practice was to search for the initial character in the
* forward direction only.
*/
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (isempty)
goto nomatch;
return (1);
}
for (off = vp->m_start.cno;; ++off) {
if (off >= len) {
nomatch: msgq(sp, M_BERR, "184|No match character on this line");
return (1);
}
startc = p[off];
cp = STRCHR(match_chars, startc);
if (cp != NULL) {
cnt = cp - match_chars;
matchc = match_chars[cnt ^ 1];
gc = cnt & 1 ? cs_prev : cs_next;
break;
}
}
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = off;
if (cs_init(sp, &cs))
return (1);
for (cnt = 1;;) {
if (gc(sp, &cs))
return (1);
if (cs.cs_flags != 0) {
if (cs.cs_flags == CS_EOF || cs.cs_flags == CS_SOF)
break;
continue;
}
if (cs.cs_ch == startc)
++cnt;
else if (cs.cs_ch == matchc && --cnt == 0)
break;
}
if (cnt) {
msgq(sp, M_BERR, "185|Matching character not found");
return (1);
}
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
/*
* If moving right, non-motion commands move to the end of the range.
* Delete and yank stay at the start.
*
* If moving left, all commands move to the end of the range.
*
* !!!
* Don't correct for leftward movement -- historic vi deleted the
* starting cursor position when deleting to a match.
*/
if (vp->m_start.lno < vp->m_stop.lno ||
(vp->m_start.lno == vp->m_stop.lno &&
vp->m_start.cno < vp->m_stop.cno))
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
else
vp->m_final = vp->m_stop;
/*
* !!!
* If the motion is across lines, and the earliest cursor position
* is at or before any non-blank characters in the line, i.e. the
* movement is cutting all of the line's text, and the later cursor
* position has nothing other than whitespace characters between it
* and the end of its line, the buffer is in line mode.
*/
if (!ISMOTION(vp) || vp->m_start.lno == vp->m_stop.lno)
return (0);
mp = vp->m_start.lno < vp->m_stop.lno ? &vp->m_start : &vp->m_stop;
if (mp->cno != 0) {
cno = 0;
if (nonblank(sp, mp->lno, &cno))
return (1);
if (cno < mp->cno)
return (0);
}
mp = vp->m_start.lno < vp->m_stop.lno ? &vp->m_stop : &vp->m_start;
if (db_get(sp, mp->lno, DBG_FATAL, &p, &len))
return (1);
for (p += mp->cno + 1, len -= mp->cno; --len; ++p)
if (!isblank(*p))
return (0);
F_SET(vp, VM_LMODE);
return (0);
}
/*
* vs_wait --
* Prompt the user to continue.
*/
static void
vs_wait(SCR *sp, int *continuep, sw_t wtype)
{
EVENT ev;
VI_PRIVATE *vip;
const char *p;
GS *gp;
size_t len;
gp = sp->gp;
vip = VIP(sp);
(void)gp->scr_move(sp, LASTLINE(sp), 0);
if (IS_ONELINE(sp))
p = msg_cmsg(sp, CMSG_CONT_S, &len);
else
switch (wtype) {
case SCROLL_W_QUIT:
p = msg_cmsg(sp, CMSG_CONT_Q, &len);
break;
case SCROLL_W_EX:
p = msg_cmsg(sp, CMSG_CONT_EX, &len);
break;
case SCROLL_W:
p = msg_cmsg(sp, CMSG_CONT, &len);
break;
default:
abort();
/* NOTREACHED */
}
(void)gp->scr_addstr(sp, p, len);
++vip->totalcount;
vip->linecount = 0;
(void)gp->scr_clrtoeol(sp);
(void)gp->scr_refresh(sp, 0);
/* Get a single character from the terminal. */
if (continuep != NULL)
*continuep = 0;
for (;;) {
if (v_event_get(sp, &ev, 0, 0))
return;
if (ev.e_event == E_CHARACTER)
break;
if (ev.e_event == E_INTERRUPT) {
ev.e_c = CH_QUIT;
F_SET(gp, G_INTERRUPTED);
break;
}
(void)gp->scr_bell(sp);
}
switch (wtype) {
case SCROLL_W_QUIT:
if (ev.e_c == CH_QUIT)
F_SET(gp, G_INTERRUPTED);
break;
case SCROLL_W_EX:
if (ev.e_c == ':' && continuep != NULL)
*continuep = 1;
break;
case SCROLL_W:
break;
}
}
int VIP_IsFlags(gedict_t* cl, int flags)
{
return ( ( VIP( cl ) & flags ) == flags );
}