/*
* v_cfirst -- [count]_
* Move to the first non-blank character in a line.
*
* PUBLIC: int v_cfirst __P((SCR *, VICMD *));
*/
int
v_cfirst(SCR *sp, VICMD *vp)
{
db_recno_t cnt, lno;
/*
* !!!
* If the _ is a motion component, it makes the command a line motion
* e.g. "d_" deletes the line. It also means that the cursor doesn't
* move.
*
* The _ command never failed in the first column.
*/
if (ISMOTION(vp))
F_SET(vp, VM_LMODE);
/*
* !!!
* Historically a specified count makes _ move down count - 1
* rows, so, "3_" is the same as "2j_".
*/
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
if (cnt != 1) {
--vp->count;
return (v_down(sp, vp));
}
/*
* Move to the first non-blank.
*
* Can't just use RCM_SET_FNB, in case _ is used as the motion
* component of another command.
*/
vp->m_stop.cno = 0;
if (nonblank(sp, vp->m_stop.lno, &vp->m_stop.cno))
return (1);
/*
* !!!
* The _ command has to fail if the file is empty and we're doing
* a delete. If deleting line 1, and 0 is the first nonblank,
* make the check.
*/
if (vp->m_stop.lno == 1 &&
vp->m_stop.cno == 0 && ISCMD(vp->rkp, 'd')) {
if (db_last(sp, &lno))
return (1);
if (lno == 0) {
v_sol(sp);
return (1);
}
}
/*
* Delete and non-motion commands move to the end of the range,
* yank stays at the start. Ignore others.
*/
vp->m_final =
ISMOTION(vp) && ISCMD(vp->rkp, 'y') ? vp->m_start : vp->m_stop;
return (0);
}
/*
* v_dollar -- [count]$
* Move to the last column.
*
* PUBLIC: int v_dollar __P((SCR *, VICMD *));
*/
int
v_dollar(SCR *sp, VICMD *vp)
{
size_t len;
int isempty;
/*
* !!!
* A count moves down count - 1 rows, so, "3$" is the same as "2j$".
*/
if ((F_ISSET(vp, VC_C1SET) ? vp->count : 1) != 1) {
/*
* !!!
* Historically, if the $ is a motion, and deleting from
* at or before the first non-blank of the line, it's a
* line motion, and the line motion flag is set.
*/
vp->m_stop.cno = 0;
if (nonblank(sp, vp->m_start.lno, &vp->m_stop.cno))
return (1);
if (ISMOTION(vp) && vp->m_start.cno <= vp->m_stop.cno)
F_SET(vp, VM_LMODE);
--vp->count;
if (v_down(sp, vp))
return (1);
}
/*
* !!!
* Historically, it was illegal to use $ as a motion command on
* an empty line. Unfortunately, even though C was historically
* aliased to c$, it (and not c$) was special cased to work on
* empty lines. Since we alias C to c$ too, we have a problem.
* To fix it, we let c$ go through, on the assumption that it's
* not a problem for it to work.
*/
if (db_eget(sp, vp->m_stop.lno, NULL, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
}
if (len == 0) {
if (ISMOTION(vp) && !ISCMD(vp->rkp, 'c')) {
v_eol(sp, NULL);
return (1);
}
return (0);
}
/*
* Non-motion commands move to the end of the range. Delete
* and yank stay at the start. Ignore others.
*/
vp->m_stop.cno = len ? len - 1 : 0;
vp->m_final = ISMOTION(vp) ? vp->m_start : vp->m_stop;
return (0);
}
static void
goto_adjust(VICMD *vp)
{
/* Guess that it's the end of the range. */
vp->m_final = vp->m_stop;
/*
* Non-motion commands move the cursor to the end of the range, and
* then to the NEXT nonblank of the line. Historic vi always moved
* to the first nonblank in the line; since the H, M, and L commands
* are logical motions in this implementation, we do the next nonblank
* so that it looks approximately the same to the user. To make this
* happen, the VM_RCM_SETNNB flag is set in the vcmd.c command table.
*
* If it's a motion, it's more complicated. The best possible solution
* is probably to display the first nonblank of the line the cursor
* will eventually rest on. This is tricky, particularly given that if
* the associated command is a delete, we don't yet know what line that
* will be. So, we clear the VM_RCM_SETNNB flag, and set the first
* nonblank flag (VM_RCM_SETFNB). Note, if the lines are sufficiently
* long, this can cause the cursor to warp out of the screen. It's too
* hard to fix.
*
* XXX
* The G command is always first nonblank, so it's okay to reset it.
*/
if (ISMOTION(vp)) {
F_CLR(vp, VM_RCM_MASK);
F_SET(vp, VM_RCM_SETFNB);
} else
return;
/*
* If moving backward in the file, delete and yank move to the end
* of the range, unless the line didn't change, in which case yank
* doesn't move. If moving forward in the file, delete and yank
* stay at the start of the range. Ignore others.
*/
if (vp->m_stop.lno < vp->m_start.lno ||
(vp->m_stop.lno == vp->m_start.lno &&
vp->m_stop.cno < vp->m_start.cno)) {
if (ISCMD(vp->rkp, 'y') && vp->m_stop.lno == vp->m_start.lno)
vp->m_final = vp->m_start;
} else
vp->m_final = vp->m_start;
}
/*
* fword --
* Move forward by words.
*/
static int
fword(SCR *sp, VICMD *vp, enum which type)
{
enum { INWORD, NOTWORD } state;
VCS cs;
u_long cnt;
int nmw, omw;
cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
cs.cs_lno = vp->m_start.lno;
cs.cs_cno = vp->m_start.cno;
if (cs_init(sp, &cs))
return (1);
/*
* If in white-space:
* If the count is 1, and it's a change command, we're done.
* Else, move to the first non-white-space character, which
* counts as a single word move. If it's a motion command,
* don't move off the end of the line.
*/
if (cs.cs_flags == CS_EMP || (cs.cs_flags == 0 && ISBLANK2(cs.cs_ch))) {
if (ISMOTION(vp) && cs.cs_flags != CS_EMP && cnt == 1) {
if (ISCMD(vp->rkp, 'c'))
return (0);
if (ISCMD(vp->rkp, 'd') || ISCMD(vp->rkp, 'y')) {
if (cs_fspace(sp, &cs))
return (1);
goto ret;
}
}
if (cs_fblank(sp, &cs))
return (1);
--cnt;
}
/*
* Cyclically move to the next word -- this involves skipping
* over word characters and then any trailing non-word characters.
* Note, for the 'w' command, the definition of a word keeps
* switching.
*/
if (type == BIGWORD)
while (cnt--) {
nmw = ISMULTIWIDTH(sp, cs.cs_ch);
for (;;) {
omw = nmw;
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
(nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
break;
}
/*
* If a motion command and we're at the end of the
* last word, we're done. Delete and yank eat any
* trailing blanks, but we don't move off the end
* of the line regardless.
*/
if (cnt == 0 && ISMOTION(vp)) {
if ((ISCMD(vp->rkp, 'd') ||
ISCMD(vp->rkp, 'y')) &&
cs_fspace(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (nmw == omw && cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
else
while (cnt--) {
state = cs.cs_flags == 0 &&
inword(cs.cs_ch) ? INWORD : NOTWORD;
nmw = ISMULTIWIDTH(sp, cs.cs_ch);
for (;;) {
omw = nmw;
if (cs_next(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
(nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
break;
if (state == INWORD) {
if (!inword(cs.cs_ch))
break;
} else
if (inword(cs.cs_ch))
break;
}
/* See comment above. */
if (cnt == 0 && ISMOTION(vp)) {
if ((ISCMD(vp->rkp, 'd') ||
ISCMD(vp->rkp, 'y')) &&
cs_fspace(sp, &cs))
return (1);
break;
}
/* Eat whitespace characters. */
if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
if (cs_fblank(sp, &cs))
return (1);
if (cs.cs_flags == CS_EOF)
goto ret;
}
/*
* If we didn't move, we must be at EOF.
*
* !!!
* That's okay for motion commands, however.
*/
ret: if (!ISMOTION(vp) &&
cs.cs_lno == vp->m_start.lno && cs.cs_cno == vp->m_start.cno) {
v_eof(sp, &vp->m_start);
return (1);
}
/* Adjust the end of the range for motion commands. */
vp->m_stop.lno = cs.cs_lno;
vp->m_stop.cno = cs.cs_cno;
if (ISMOTION(vp) && cs.cs_flags == 0)
--vp->m_stop.cno;
/*
* 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);
}
/*
* mark --
* Mark commands.
*/
static int
mark(SCR *sp, VICMD *vp, int getmark, enum which cmd)
{
dir_t dir;
MARK m;
size_t len;
if (getmark && mark_get(sp, vp->character, &vp->m_stop, M_BERR))
return (1);
/*
* !!!
* Historically, BQMARKS for character positions that no longer
* existed acted as FQMARKS.
*
* FQMARKS move to the first non-blank.
*/
switch (cmd) {
case BQMARK:
if (db_get(sp, vp->m_stop.lno, DBG_FATAL, NULL, &len))
return (1);
if (vp->m_stop.cno < len ||
(vp->m_stop.cno == len && len == 0))
break;
if (ISMOTION(vp))
F_SET(vp, VM_LMODE);
cmd = FQMARK;
/* FALLTHROUGH */
case FQMARK:
vp->m_stop.cno = 0;
if (nonblank(sp, vp->m_stop.lno, &vp->m_stop.cno))
return (1);
break;
default:
abort();
}
/* Non-motion commands move to the end of the range. */
if (!ISMOTION(vp)) {
vp->m_final = vp->m_stop;
return (0);
}
/*
* !!!
* If a motion component to a BQMARK, the cursor has to move.
*/
if (cmd == BQMARK &&
vp->m_stop.lno == vp->m_start.lno &&
vp->m_stop.cno == vp->m_start.cno) {
v_nomove(sp);
return (1);
}
/*
* If the motion is in the reverse direction, switch the start and
* stop MARK's so that it's in a forward direction. (There's no
* reason for this other than to make the tests below easier. The
* code in vi.c:vi() would have done the switch.) Both forward
* and backward motions can happen for any kind of search command.
*/
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)) {
m = vp->m_start;
vp->m_start = vp->m_stop;
vp->m_stop = m;
dir = BACKWARD;
} else
dir = FORWARD;
/*
* Yank cursor motion, when associated with marks as motion commands,
* historically behaved as follows:
*
* ` motion ' motion
* Line change? Line change?
* Y N Y N
* -------------- ---------------
* FORWARD: | NM NM | NM NM
* | |
* BACKWARD: | M M | M NM(1)
*
* where NM means the cursor didn't move, and M means the cursor
* moved to the mark.
*
* As the cursor was usually moved for yank commands associated
* with backward motions, this implementation regularizes it by
* changing the NM at position (1) to be an M. This makes mark
* motions match search motions, which is probably A Good Thing.
*
* Delete cursor motion was always to the start of the text region,
* regardless. Ignore other motion commands.
*/
#ifdef HISTORICAL_PRACTICE
if (ISCMD(vp->rkp, 'y')) {
if ((cmd == BQMARK ||
(cmd == FQMARK && vp->m_start.lno != vp->m_stop.lno)) &&
(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 = vp->m_stop;
} else if (ISCMD(vp->rkp, 'd'))
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 = vp->m_stop;
#else
vp->m_final = vp->m_start;
#endif
/*
* Forward marks are always line oriented, and it's set in the
* vcmd.c table.
*/
if (cmd == FQMARK)
return (0);
/*
* BQMARK'S moving backward and starting at column 0, and ones moving
* forward and ending at column 0 are corrected to the last column of
* the previous line. Otherwise, adjust the starting/ending point to
* the character before the current one (this is safe because we know
* the search had to move to succeed).
*
* Mark motions become line mode opertions if they start at the first
* nonblank and end at column 0 of another line.
*/
if (vp->m_start.lno < vp->m_stop.lno && vp->m_stop.cno == 0) {
if (db_get(sp, --vp->m_stop.lno, DBG_FATAL, NULL, &len))
return (1);
vp->m_stop.cno = len ? len - 1 : 0;
len = 0;
if (nonblank(sp, vp->m_start.lno, &len))
return (1);
if (vp->m_start.cno <= len)
F_SET(vp, VM_LMODE);
} else
--vp->m_stop.cno;
return (0);
}