/*
* v_subst -- [buffer][count]s
* Substitute characters.
*
* PUBLIC: int v_subst __P((SCR *, VICMD *));
*/
int
v_subst(SCR *sp, VICMD *vp)
{
size_t len;
u_int32_t flags;
int isempty;
CHAR_T *p;
flags = set_txt_std(sp, vp, 0);
sp->showmode = SM_CHANGE;
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
LF_SET(TXT_APPENDEOL);
} else {
if (len == 0)
LF_SET(TXT_APPENDEOL);
LF_SET(TXT_EMARK | TXT_OVERWRITE);
}
vp->m_stop.lno = vp->m_start.lno;
vp->m_stop.cno =
vp->m_start.cno + (F_ISSET(vp, VC_C1SET) ? vp->count - 1 : 0);
if (vp->m_stop.cno > len - 1)
vp->m_stop.cno = len - 1;
if (p != NULL && cut(sp,
F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
&vp->m_start, &vp->m_stop, 0))
return (1);
return (v_txt(sp, vp, &vp->m_stop, p, len, 0, OOBLNO, 1, flags));
}
/*
* v_Replace -- [count]R
* Overwrite multiple characters.
*
* PUBLIC: int v_Replace __P((SCR *, VICMD *));
*/
int
v_Replace(SCR *sp, VICMD *vp)
{
size_t len;
u_int32_t flags;
int isempty;
CHAR_T *p;
flags = set_txt_std(sp, vp, 0);
sp->showmode = SM_REPLACE;
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
LF_SET(TXT_APPENDEOL);
} else {
if (len == 0)
LF_SET(TXT_APPENDEOL);
LF_SET(TXT_OVERWRITE | TXT_REPLACE);
}
vp->m_stop.lno = vp->m_start.lno;
vp->m_stop.cno = len ? len - 1 : 0;
return (v_txt(sp, vp, &vp->m_stop, p, len,
0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
}
/*
* v_ia -- [count]a
* [count]A
* Append text to the cursor position.
*
* PUBLIC: int v_ia __P((SCR *, VICMD *));
*/
int
v_ia(SCR *sp, VICMD *vp)
{
size_t len;
u_int32_t flags;
int isempty;
CHAR_T *p;
flags = set_txt_std(sp, vp, 0);
sp->showmode = SM_APPEND;
sp->lno = vp->m_start.lno;
/* Move the cursor one column to the right and repaint the screen. */
if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
LF_SET(TXT_APPENDEOL);
} else if (len) {
if (len == sp->cno + 1) {
sp->cno = len;
LF_SET(TXT_APPENDEOL);
} else
++sp->cno;
} else
LF_SET(TXT_APPENDEOL);
return (v_txt(sp, vp, NULL, p, len,
0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
}
/*
* set_txt_std --
* Initialize text processing flags.
*/
static u_int32_t
set_txt_std(SCR *sp, VICMD *vp, u_int32_t flags)
{
LF_SET(TXT_CNTRLT |
TXT_ESCAPE | TXT_MAPINPUT | TXT_RECORD | TXT_RESOLVE);
if (F_ISSET(vp, VC_ISDOT))
LF_SET(TXT_REPLAY);
if (O_ISSET(sp, O_ALTWERASE))
LF_SET(TXT_ALTWERASE);
if (O_ISSET(sp, O_AUTOINDENT))
LF_SET(TXT_AUTOINDENT);
if (O_ISSET(sp, O_BEAUTIFY))
LF_SET(TXT_BEAUTIFY);
if (O_ISSET(sp, O_SHOWMATCH))
LF_SET(TXT_SHOWMATCH);
if (F_ISSET(sp, SC_SCRIPT))
LF_SET(TXT_CR);
if (O_ISSET(sp, O_TTYWERASE))
LF_SET(TXT_TTYWERASE);
/*
* !!!
* Mapped keys were sometimes unaffected by the wrapmargin option
* in the historic 4BSD vi. Consider the following commands, where
* each is executed on an empty line, in an 80 column screen, with
* the wrapmargin value set to 60.
*
* aABC DEF <ESC>....
* :map K aABC DEF ^V<ESC><CR>KKKKK
* :map K 5aABC DEF ^V<ESC><CR>K
*
* The first and second commands are affected by wrapmargin. The
* third is not. (If the inserted text is itself longer than the
* wrapmargin value, i.e. if the "ABC DEF " string is replaced by
* something that's longer than 60 columns from the beginning of
* the line, the first two commands behave as before, but the third
* command gets fairly strange.) The problem is that people wrote
* macros that depended on the third command NOT being affected by
* wrapmargin, as in this gem which centers lines:
*
* map #c $mq81a ^V^[81^V^V|D`qld0:s/ / /g^V^M$p
*
* For compatibility reasons, we try and make it all work here. I
* offer no hope that this is right, but it's probably pretty close.
*
* XXX
* Once I work my courage up, this is all gonna go away. It's too
* evil to survive.
*/
if ((O_ISSET(sp, O_WRAPLEN) || O_ISSET(sp, O_WRAPMARGIN)) &&
(!MAPPED_KEYS_WAITING(sp) || !F_ISSET(vp, VC_C1SET)))
LF_SET(TXT_WRAPMARGIN);
return (flags);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
uint32_t flags;
bool bitmap, bulk;
bitmap = bulk = false;
flags = 0;
WT_RET(__wt_config_gets_def(session, cfg, "bulk", 0, &cval));
if (cval.type == WT_CONFIG_ITEM_BOOL ||
(cval.type == WT_CONFIG_ITEM_NUM &&
(cval.val == 0 || cval.val == 1))) {
bitmap = false;
bulk = cval.val != 0;
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = true;
else
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_DHANDLE_EXCLUSIVE);
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:")) {
/*
* If we are opening a bulk cursor, get the handle while
* holding the checkpoint lock. This prevents a bulk cursor
* open failing with EBUSY due to a database-wide checkpoint.
*/
if (bulk)
__wt_spin_lock(
session, &S2C(session)->checkpoint_lock);
ret = __wt_session_get_btree_ckpt(session, uri, cfg, flags);
if (bulk)
__wt_spin_unlock(
session, &S2C(session)->checkpoint_lock);
WT_RET(ret);
} else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
/* Increment the data-source's in-use counter. */
__wt_cursor_dhandle_incr_use(session);
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* v_search --
* The search commands.
*/
static int
v_search(SCR *sp, VICMD *vp, CHAR_T *ptrn, size_t plen, u_int flags, dir_t dir)
{
/* Display messages. */
LF_SET(SEARCH_MSG);
/* If it's a motion search, offset past end-of-line is okay. */
if (ISMOTION(vp))
LF_SET(SEARCH_EOL);
/*
* XXX
* Warn if the search wraps. See the comment above, in v_exaddr().
*/
if (!KEYS_WAITING(sp))
LF_SET(SEARCH_WMSG);
switch (dir) {
case BACKWARD:
if (b_search(sp,
&vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags))
return (1);
break;
case FORWARD:
if (f_search(sp,
&vp->m_start, &vp->m_stop, ptrn, plen, NULL, flags))
return (1);
break;
case NOTSET:
msgq(sp, M_ERR, "189|No previous search pattern");
return (1);
default:
abort();
}
/* Correct motion commands, otherwise, simply move to the location. */
if (ISMOTION(vp)) {
if (v_correct(sp, vp, 0))
return(1);
} else
vp->m_final = vp->m_stop;
return (0);
}
/*
* 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);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
uint32_t flags;
/*
* Bulk and no cache handles are exclusive and may not be used by more
* than a single thread.
* Additionally set the discard flag on no cache handles so they are
* destroyed on close.
*/
flags = 0;
WT_RET(__wt_config_gets_defno(session, cfg, "bulk", &cval));
if (cval.val != 0)
LF_SET(WT_BTREE_EXCLUSIVE | WT_BTREE_BULK);
WT_RET(__wt_config_gets_defno(session, cfg, "no_cache", &cval));
if (cval.val != 0)
LF_SET(WT_BTREE_EXCLUSIVE | WT_BTREE_NO_CACHE);
/* TODO: handle projections. */
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:"))
WT_RET(__wt_session_get_btree_ckpt(session, uri, cfg, flags));
else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
(void)__wt_session_release_btree(session);
return (ret);
}
/*
* 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);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
int bitmap, bulk;
uint32_t flags;
flags = 0;
WT_RET(__wt_config_gets_defno(session, cfg, "bulk", &cval));
if (cval.type == ITEM_NUM && (cval.val == 0 || cval.val == 1)) {
bitmap = 0;
bulk = (cval.val != 0);
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = 1;
else
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_BTREE_EXCLUSIVE);
/* TODO: handle projections. */
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:"))
WT_RET(__wt_session_get_btree_ckpt(session, uri, cfg, flags));
else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__wt_curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* v_ii -- [count]i
* [count]I
* Insert text at the cursor position.
*
* PUBLIC: int v_ii __P((SCR *, VICMD *));
*/
int
v_ii(SCR *sp, VICMD *vp)
{
size_t len;
u_int32_t flags;
int isempty;
CHAR_T *p;
flags = set_txt_std(sp, vp, 0);
sp->showmode = SM_INSERT;
sp->lno = vp->m_start.lno;
if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
}
if (len == 0)
LF_SET(TXT_APPENDEOL);
return (v_txt(sp, vp, NULL, p, len,
0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
}
/*
* v_esearch -- <dialog box>
* Search command from the screen.
*
* PUBLIC: int v_esearch __P((SCR *, VICMD *));
*/
int
v_esearch(SCR *sp, VICMD *vp)
{
int flags;
LF_INIT(SEARCH_NOOPT);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_EXT))
LF_SET(SEARCH_EXTEND);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_IC))
LF_SET(SEARCH_IC);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_ICL))
LF_SET(SEARCH_ICL);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_INCR))
LF_SET(SEARCH_INCR);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_LIT))
LF_SET(SEARCH_LITERAL);
if (FL_ISSET(vp->ev.e_flags, VI_SEARCH_WR))
LF_SET(SEARCH_WRAP);
return (v_search(sp, vp, vp->ev.e_csp, vp->ev.e_len, flags,
FL_ISSET(vp->ev.e_flags, VI_SEARCH_REV) ? BACKWARD : FORWARD));
}
/*
* v_change -- [buffer][count]c[count]motion
* [buffer][count]C
* [buffer][count]S
* Change command.
*
* PUBLIC: int v_change __P((SCR *, VICMD *));
*/
int
v_change(SCR *sp, VICMD *vp)
{
size_t blen, len;
u_int32_t flags;
int isempty, lmode, rval;
CHAR_T *bp;
CHAR_T *p;
/*
* 'c' can be combined with motion commands that set the resulting
* cursor position, i.e. "cG". Clear the VM_RCM flags and make the
* resulting cursor position stick, inserting text has its own rules
* for cursor positioning.
*/
F_CLR(vp, VM_RCM_MASK);
F_SET(vp, VM_RCM_SET);
/*
* Find out if the file is empty, it's easier to handle it as a
* special case.
*/
if (vp->m_start.lno == vp->m_stop.lno &&
db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
return (v_ia(sp, vp));
}
flags = set_txt_std(sp, vp, 0);
sp->showmode = SM_CHANGE;
/*
* Move the cursor to the start of the change. Note, if autoindent
* is turned on, the cc command in line mode changes from the first
* *non-blank* character of the line, not the first character. And,
* to make it just a bit more exciting, the initial space is handled
* as auto-indent characters.
*/
lmode = F_ISSET(vp, VM_LMODE) ? CUT_LINEMODE : 0;
if (lmode) {
vp->m_start.cno = 0;
if (O_ISSET(sp, O_AUTOINDENT)) {
if (nonblank(sp, vp->m_start.lno, &vp->m_start.cno))
return (1);
LF_SET(TXT_AICHARS);
}
}
sp->lno = vp->m_start.lno;
sp->cno = vp->m_start.cno;
LOG_CORRECT;
/*
* If not in line mode and changing within a single line, copy the
* text and overwrite it.
*/
if (!lmode && vp->m_start.lno == vp->m_stop.lno) {
/*
* !!!
* Historic practice, c did not cut into the numeric buffers,
* only the unnamed one.
*/
if (cut(sp,
F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
&vp->m_start, &vp->m_stop, lmode))
return (1);
if (len == 0)
LF_SET(TXT_APPENDEOL);
LF_SET(TXT_EMARK | TXT_OVERWRITE);
return (v_txt(sp, vp, &vp->m_stop, p, len,
0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
}
/*
* It's trickier if in line mode or changing over multiple lines. If
* we're in line mode delete all of the lines and insert a replacement
* line which the user edits. If there was leading whitespace in the
* first line being changed, we copy it and use it as the replacement.
* If we're not in line mode, we delete the text and start inserting.
*
* !!!
* Copy the text. Historic practice, c did not cut into the numeric
* buffers, only the unnamed one.
*/
if (cut(sp,
F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
&vp->m_start, &vp->m_stop, lmode))
return (1);
/* If replacing entire lines and there's leading text. */
if (lmode && vp->m_start.cno) {
/*
* Get a copy of the first line changed, and copy out the
* leading text.
*/
if (db_get(sp, vp->m_start.lno, DBG_FATAL, &p, &len))
return (1);
GET_SPACE_RETW(sp, bp, blen, vp->m_start.cno);
MEMMOVEW(bp, p, vp->m_start.cno);
} else
bp = NULL;
/* Delete the text. */
if (del(sp, &vp->m_start, &vp->m_stop, lmode))
return (1);
/* If replacing entire lines, insert a replacement line. */
if (lmode) {
if (db_insert(sp, vp->m_start.lno, bp, vp->m_start.cno))
return (1);
sp->lno = vp->m_start.lno;
len = sp->cno = vp->m_start.cno;
}
/* Get the line we're editing. */
if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
if (!isempty)
return (1);
len = 0;
}
/* Check to see if we're appending to the line. */
if (vp->m_start.cno >= len)
LF_SET(TXT_APPENDEOL);
rval = v_txt(sp, vp, NULL, p, len,
0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags);
if (bp != NULL)
FREE_SPACEW(sp, bp, blen);
return (rval);
}
/*
* __wt_btcur_prev --
* Move to the previous record in the tree.
*/
int
__wt_btcur_prev(WT_CURSOR_BTREE *cbt, bool truncating)
{
WT_DECL_RET;
WT_PAGE *page;
WT_SESSION_IMPL *session;
uint32_t flags;
bool newpage;
session = (WT_SESSION_IMPL *)cbt->iface.session;
WT_STAT_FAST_CONN_INCR(session, cursor_prev);
WT_STAT_FAST_DATA_INCR(session, cursor_prev);
flags = WT_READ_PREV | WT_READ_SKIP_INTL; /* Tree walk flags. */
if (truncating)
LF_SET(WT_READ_TRUNCATE);
WT_RET(__cursor_func_init(cbt, false));
/*
* If we aren't already iterating in the right direction, there's
* some setup to do.
*/
if (!F_ISSET(cbt, WT_CBT_ITERATE_PREV))
__wt_btcur_iterate_setup(cbt);
/*
* Walk any page we're holding until the underlying call returns not-
* found. Then, move to the previous page, until we reach the start
* of the file.
*/
for (newpage = false;; newpage = true) {
page = cbt->ref == NULL ? NULL : cbt->ref->page;
WT_ASSERT(session, page == NULL || !WT_PAGE_IS_INTERNAL(page));
/*
* The last page in a column-store has appended entries.
* We handle it separately from the usual cursor code:
* it's only that one page and it's in a simple format.
*/
if (newpage && page != NULL && page->type != WT_PAGE_ROW_LEAF &&
(cbt->ins_head = WT_COL_APPEND(page)) != NULL)
F_SET(cbt, WT_CBT_ITERATE_APPEND);
if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_append_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_append_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret == 0)
break;
F_CLR(cbt, WT_CBT_ITERATE_APPEND);
if (ret != WT_NOTFOUND)
break;
newpage = true;
}
if (page != NULL) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_prev(cbt, newpage);
break;
case WT_PAGE_ROW_LEAF:
ret = __cursor_row_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret != WT_NOTFOUND)
break;
}
/*
* If we saw a lot of deleted records on this page, or we went
* all the way through a page and only saw deleted records, try
* to evict the page when we release it. Otherwise repeatedly
* deleting from the beginning of a tree can have quadratic
* performance. Take care not to force eviction of pages that
* are genuinely empty, in new trees.
*/
if (page != NULL &&
(cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD ||
(newpage && cbt->page_deleted_count > 0)))
__wt_page_evict_soon(page);
cbt->page_deleted_count = 0;
WT_ERR(__wt_tree_walk(session, &cbt->ref, flags));
WT_ERR_TEST(cbt->ref == NULL, WT_NOTFOUND);
}
err: if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* __tree_walk_internal --
* Move to the next/previous page in the tree.
*/
static inline int
__tree_walk_internal(WT_SESSION_IMPL *session,
WT_REF **refp, uint64_t *walkcntp,
int (*skip_func)(WT_SESSION_IMPL *, WT_REF *, void *, bool *),
void *func_cookie, uint32_t flags)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE_INDEX *pindex;
WT_REF *couple, *couple_orig, *ref;
uint32_t slot;
bool empty_internal, initial_descent, prev, skip;
btree = S2BT(session);
pindex = NULL;
empty_internal = initial_descent = false;
/*
* Tree walks are special: they look inside page structures that splits
* may want to free. Publish that the tree is active during this
* window.
*/
WT_ENTER_PAGE_INDEX(session);
/* Walk should never instantiate deleted pages. */
LF_SET(WT_READ_NO_EMPTY);
/*
* !!!
* Fast-truncate currently only works on row-store trees.
*/
if (btree->type != BTREE_ROW)
LF_CLR(WT_READ_TRUNCATE);
prev = LF_ISSET(WT_READ_PREV) ? 1 : 0;
/*
* There are multiple reasons and approaches to walking the in-memory
* tree:
*
* (1) finding pages to evict (the eviction server);
* (2) writing just dirty leaves or internal nodes (checkpoint);
* (3) discarding pages (close);
* (4) truncating pages in a range (fast truncate);
* (5) skipping pages based on outside information (compaction);
* (6) cursor scans (applications).
*
* Except for cursor scans and compaction, the walk is limited to the
* cache, no pages are read. In all cases, hazard pointers protect the
* walked pages from eviction.
*
* Walks use hazard-pointer coupling through the tree and that's OK
* (hazard pointers can't deadlock, so there's none of the usual
* problems found when logically locking up a btree). If the eviction
* thread tries to evict the active page, it fails because of our
* hazard pointer. If eviction tries to evict our parent, that fails
* because the parent has a child page that can't be discarded. We do
* play one game: don't couple up to our parent and then back down to a
* new leaf, couple to the next page to which we're descending, it
* saves a hazard-pointer swap for each cursor page movement.
*
* !!!
* NOTE: we depend on the fact it's OK to release a page we don't hold,
* that is, it's OK to release couple when couple is set to NULL.
*
* Take a copy of any held page and clear the return value. Remember
* the hazard pointer we're currently holding.
*
* Clear the returned value, it makes future error handling easier.
*/
couple = couple_orig = ref = *refp;
*refp = NULL;
/* If no page is active, begin a walk from the start/end of the tree. */
if (ref == NULL) {
restart: /*
* We can be here with a NULL or root WT_REF; the page release
* function handles them internally, don't complicate this code
* by calling them out.
*/
WT_ERR(__wt_page_release(session, couple, flags));
/*
* We're not supposed to walk trees without root pages. As this
* has not always been the case, assert to debug that change.
*/
WT_ASSERT(session, btree->root.page != NULL);
couple = couple_orig = ref = &btree->root;
initial_descent = true;
goto descend;
}
/*
* If the active page was the root, we've reached the walk's end; we
* only get here if we've returned the root to our caller, so we're
* holding no hazard pointers.
*/
if (__wt_ref_is_root(ref))
goto done;
/* Figure out the current slot in the WT_REF array. */
__ref_index_slot(session, ref, &pindex, &slot);
for (;;) {
/*
* If we're at the last/first slot on the internal page, return
* it in post-order traversal. Otherwise move to the next/prev
* slot and left/right-most element in that subtree.
*/
while ((prev && slot == 0) ||
(!prev && slot == pindex->entries - 1)) {
/* Ascend to the parent. */
__ref_ascend(session, &ref, &pindex, &slot);
/*
* If at the root and returning internal pages, return
* the root page, otherwise we're done. Regardless, no
* hazard pointer is required, release the one we hold.
*/
if (__wt_ref_is_root(ref)) {
WT_ERR(__wt_page_release(
session, couple, flags));
if (!LF_ISSET(WT_READ_SKIP_INTL))
*refp = ref;
goto done;
}
/*
* If we got all the way through an internal page and
* all of the child pages were deleted, mark it for
* eviction.
*/
if (empty_internal && pindex->entries > 1) {
__wt_page_evict_soon(session, ref);
empty_internal = false;
}
/*
* Optionally return internal pages. Swap our previous
* hazard pointer for the page we'll return. We don't
* handle restart or not-found returns, it would require
* additional complexity and is not a possible return:
* we're moving to the parent of the current child page,
* the parent can't have been evicted.
*/
if (!LF_ISSET(WT_READ_SKIP_INTL)) {
WT_ERR(__wt_page_swap(
session, couple, ref, flags));
*refp = ref;
goto done;
}
}
if (prev)
--slot;
else
++slot;
if (walkcntp != NULL)
++*walkcntp;
for (;;) {
/*
* Move to the next slot, and set the reference hint if
* it's wrong (used when we continue the walk). We don't
* always update the hints when splitting, it's expected
* for them to be incorrect in some workloads.
*/
ref = pindex->index[slot];
if (ref->pindex_hint != slot)
ref->pindex_hint = slot;
/*
* If we see any child states other than deleted, the
* page isn't empty.
*/
if (ref->state != WT_REF_DELETED &&
!LF_ISSET(WT_READ_TRUNCATE))
empty_internal = false;
if (LF_ISSET(WT_READ_CACHE)) {
/*
* Only look at unlocked pages in memory:
* fast-path some common cases.
*/
if (LF_ISSET(WT_READ_NO_WAIT) &&
ref->state != WT_REF_MEM)
break;
/* Skip lookaside pages if not requested. */
if (ref->state == WT_REF_LOOKASIDE &&
!LF_ISSET(WT_READ_LOOKASIDE))
break;
} else if (LF_ISSET(WT_READ_TRUNCATE)) {
/*
* Avoid pulling a deleted page back in to try
* to delete it again.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
/*
* If deleting a range, try to delete the page
* without instantiating it.
*/
WT_ERR(__wt_delete_page(session, ref, &skip));
if (skip)
break;
empty_internal = false;
} else if (skip_func != NULL) {
WT_ERR(skip_func(session,
ref, func_cookie, &skip));
if (skip)
break;
} else {
/*
* Try to skip deleted pages visible to us.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
}
ret = __wt_page_swap(session, couple, ref,
WT_READ_NOTFOUND_OK | WT_READ_RESTART_OK | flags);
/*
* Not-found is an expected return when only walking
* in-cache pages, or if we see a deleted page.
*/
if (ret == WT_NOTFOUND) {
ret = 0;
break;
}
/*
* The page we're moving to might have split, in which
* case move to the last position we held.
*/
if (ret == WT_RESTART) {
ret = 0;
/*
* If a cursor is setting up at the end of the
* tree, we can't use our parent page's index,
* because it may have already split; restart
* the walk.
*/
if (prev && initial_descent)
goto restart;
/*
* If a new walk that never coupled from the
* root to a new saved position in the tree,
* restart the walk.
*/
if (couple == &btree->root)
goto restart;
/*
* If restarting from some original position,
* repeat the increment or decrement we made at
* that time. Otherwise, couple is an internal
* page we've acquired after moving from that
* starting position and we can treat it as a
* new page. This works because we never acquire
* a hazard pointer on a leaf page we're not
* going to return to our caller, this will quit
* working if that ever changes.
*/
WT_ASSERT(session,
couple == couple_orig ||
WT_PAGE_IS_INTERNAL(couple->page));
ref = couple;
__ref_index_slot(session, ref, &pindex, &slot);
if (couple == couple_orig)
break;
}
WT_ERR(ret);
couple = ref;
/*
* A new page: configure for traversal of any internal
* page's children, else return the leaf page.
*/
if (WT_PAGE_IS_INTERNAL(ref->page)) {
descend: empty_internal = true;
/*
* There's a split race when a cursor is setting
* up at the end of the tree or moving backwards
* through the tree and descending a level. When
* splitting an internal page into its parent,
* we move the WT_REF structures and update the
* parent's page index before updating the split
* page's page index, and it's not an atomic
* update. A thread can read the parent page's
* replacement page index, then read the split
* page's original index, or the parent page's
* original and the split page's replacement.
*
* This isn't a problem for a cursor setting up
* at the start of the tree or moving forwards
* through the tree because we do right-hand
* splits on internal pages and the initial part
* of the split page's namespace won't change as
* part of a split. A thread reading the parent
* page's and split page's indexes will move to
* the same slot no matter what order of indexes
* are read.
*
* Handle a cursor setting up at the end of the
* tree or moving backwards through the tree.
*/
if (!prev) {
WT_INTL_INDEX_GET(
session, ref->page, pindex);
slot = 0;
} else if (initial_descent) {
if (!__ref_initial_descent_prev(
session, ref, &pindex))
goto restart;
slot = pindex->entries - 1;
} else {
__ref_descend_prev(
session, ref, &pindex);
slot = pindex->entries - 1;
}
continue;
}
/*
* The tree-walk restart code knows we return any leaf
* page we acquire (never hazard-pointer coupling on
* after acquiring a leaf page), and asserts no restart
* happens while holding a leaf page. This page must be
* returned to our caller.
*/
*refp = ref;
goto done;
}
}
done:
err: WT_LEAVE_PAGE_INDEX(session);
return (ret);
}
/*将btree cursor移动到下一个记录*/
int __wt_btcur_next(WT_CURSOR_BTREE *cbt, int truncating)
{
WT_DECL_RET;
WT_PAGE *page;
WT_SESSION_IMPL *session;
uint32_t flags;
int newpage;
session = (WT_SESSION_IMPL *)cbt->iface.session;
WT_STAT_FAST_CONN_INCR(session, cursor_next);
WT_STAT_FAST_DATA_INCR(session, cursor_next);
/*btree 扫描标示*/
flags = WT_READ_SKIP_INTL;
if (truncating)
LF_SET(WT_READ_TRUNCATE);
/*激活一个btree cursor*/
WT_RET(__cursor_func_init(cbt, 0));
/*初始化cursor*/
if (!F_ISSET(cbt, WT_CBT_ITERATE_NEXT))
__wt_btcur_iterate_setup(cbt, 1);
/*对btree的扫描*/
for (;;){
page = cbt->ref == NULL ? NULL : cbt->ref->page;
WT_ASSERT(session, page == NULL || !WT_PAGE_IS_INTERNAL(page));
/*column store append方式，在insert header上做扫描*/
if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)){
switch (page->type){
case WT_PAGE_COL_FIX:
ret = __cursor_fix_append_next(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_append_next(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret == 0)
break;
/*清除掉column store的标记*/
F_CLR(cbt, WT_CBT_ITERATE_APPEND);
if (ret != WT_NOTFOUND)
break;
}
else if (page != NULL){
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_next(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_next(cbt, newpage);
break;
case WT_PAGE_ROW_LEAF:
ret = __cursor_row_next(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
/*找到对应的记录了，直接返回*/
if (ret != WT_NOTFOUND)
break;
/*假如是column store方式，检查是否要扫描insert header list*/
if (page->type != WT_PAGE_ROW_LEAF && (cbt->ins_head = WT_COL_APPEND(page)) != NULL) {
F_SET(cbt, WT_CBT_ITERATE_APPEND);
continue;
}
}
/*删除的记录太多，对page进行重组，增大page的填充因子*/
if (page != NULL && (cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD || (newpage && cbt->page_deleted_count > 0))){
__wt_page_evict_soon(page);
}
cbt->page_deleted_count = 0;
/*btree cursor跳转到下一个page上*/
WT_ERR(__wt_tree_walk(session, &cbt->ref, NULL, flags));
WT_ERR_TEST(cbt->ref == NULL, WT_NOTFOUND);
}
err:
if (ret != 0) /*失败了，恢复cursor的状态*/
WT_TRET(__cursor_reset(cbt));
return ret;
}
/*
* __wt_dirlist --
* Get a list of files from a directory, optionally filtered by
* a given prefix.
*/
int
__wt_dirlist(WT_SESSION_IMPL *session, const char *dir, const char *prefix,
uint32_t flags, char ***dirlist, u_int *countp)
{
struct dirent *dp;
DIR *dirp;
WT_DECL_RET;
size_t dirallocsz;
u_int count, dirsz;
int match;
char **entries, *path;
*dirlist = NULL;
*countp = 0;
WT_RET(__wt_filename(session, dir, &path));
dirp = NULL;
dirallocsz = 0;
dirsz = 0;
entries = NULL;
if (flags == 0)
LF_SET(WT_DIRLIST_INCLUDE);
WT_ERR(__wt_verbose(session, WT_VERB_FILEOPS,
"wt_dirlist of %s %s prefix %s",
path, LF_ISSET(WT_DIRLIST_INCLUDE) ? "include" : "exclude",
prefix == NULL ? "all" : prefix));
WT_SYSCALL_RETRY(((dirp = opendir(path)) == NULL ? 1 : 0), ret);
if (ret != 0)
WT_ERR_MSG(session, ret, "%s: opendir", path);
for (dirsz = 0, count = 0; (dp = readdir(dirp)) != NULL;) {
/*
* Skip . and ..
*/
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
match = 0;
if (prefix != NULL &&
((LF_ISSET(WT_DIRLIST_INCLUDE) &&
WT_PREFIX_MATCH(dp->d_name, prefix)) ||
(LF_ISSET(WT_DIRLIST_EXCLUDE) &&
!WT_PREFIX_MATCH(dp->d_name, prefix))))
match = 1;
if (prefix == NULL || match) {
/*
* We have a file name we want to return.
*/
count++;
if (count > dirsz) {
dirsz += WT_DIR_ENTRY;
WT_ERR(__wt_realloc_def(
session, &dirallocsz, dirsz, &entries));
}
WT_ERR(__wt_strdup(
session, dp->d_name, &entries[count-1]));
}
}
if (count > 0)
*dirlist = entries;
*countp = count;
err:
if (dirp != NULL)
(void)closedir(dirp);
__wt_free(session, path);
if (ret == 0)
return (0);
if (*dirlist != NULL) {
for (count = dirsz; count > 0; count--)
__wt_free(session, entries[count]);
__wt_free(session, entries);
}
WT_RET_MSG(session, ret, "dirlist %s prefix %s", dir, prefix);
}
/*
* __wt_curfile_open --
* WT_SESSION->open_cursor method for the btree cursor type.
*/
int
__wt_curfile_open(WT_SESSION_IMPL *session, const char *uri,
WT_CURSOR *owner, const char *cfg[], WT_CURSOR **cursorp)
{
WT_CONFIG_ITEM cval;
WT_DECL_RET;
uint32_t flags;
bool bitmap, bulk, checkpoint_wait;
bitmap = bulk = false;
checkpoint_wait = true;
flags = 0;
/*
* Decode the bulk configuration settings. In memory databases
* ignore bulk load.
*/
if (!F_ISSET(S2C(session), WT_CONN_IN_MEMORY)) {
WT_RET(__wt_config_gets_def(session, cfg, "bulk", 0, &cval));
if (cval.type == WT_CONFIG_ITEM_BOOL ||
(cval.type == WT_CONFIG_ITEM_NUM &&
(cval.val == 0 || cval.val == 1))) {
bitmap = false;
bulk = cval.val != 0;
} else if (WT_STRING_MATCH("bitmap", cval.str, cval.len))
bitmap = bulk = true;
/*
* Unordered bulk insert is a special case used
* internally by index creation on existing tables. It
* doesn't enforce any special semantics at the file
* level. It primarily exists to avoid some locking
* problems between LSM and index creation.
*/
else if (!WT_STRING_MATCH("unordered", cval.str, cval.len))
WT_RET_MSG(session, EINVAL,
"Value for 'bulk' must be a boolean or 'bitmap'");
if (bulk) {
WT_RET(__wt_config_gets(session,
cfg, "checkpoint_wait", &cval));
checkpoint_wait = cval.val != 0;
}
}
/* Bulk handles require exclusive access. */
if (bulk)
LF_SET(WT_BTREE_BULK | WT_DHANDLE_EXCLUSIVE);
/* Get the handle and lock it while the cursor is using it. */
if (WT_PREFIX_MATCH(uri, "file:")) {
/*
* If we are opening exclusive and don't want a bulk cursor
* open to fail with EBUSY due to a database-wide checkpoint,
* get the handle while holding the checkpoint lock.
*/
if (LF_ISSET(WT_DHANDLE_EXCLUSIVE) && checkpoint_wait)
WT_WITH_CHECKPOINT_LOCK(session,
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags));
else
ret = __wt_session_get_btree_ckpt(
session, uri, cfg, flags);
WT_RET(ret);
} else
WT_RET(__wt_bad_object_type(session, uri));
WT_ERR(__curfile_create(session, owner, cfg, bulk, bitmap, cursorp));
return (0);
err: /* If the cursor could not be opened, release the handle. */
WT_TRET(__wt_session_release_btree(session));
return (ret);
}
/*
* exwr --
* The guts of the ex write commands.
*/
static int
exwr(SCR *sp, EXCMD *cmdp, enum which cmd)
{
MARK rm;
int flags;
char *name;
CHAR_T *p = NULL;
size_t nlen;
char *n;
int rc;
EX_PRIVATE *exp;
NEEDFILE(sp, cmdp);
/* All write commands can have an associated '!'. */
LF_INIT(FS_POSSIBLE);
if (FL_ISSET(cmdp->iflags, E_C_FORCE))
LF_SET(FS_FORCE);
/* Skip any leading whitespace. */
if (cmdp->argc != 0)
for (p = cmdp->argv[0]->bp; *p != '\0' && cmdskip(*p); ++p);
/* If "write !" it's a pipe to a utility. */
if (cmdp->argc != 0 && cmd == WRITE && *p == '!') {
/* Secure means no shell access. */
if (O_ISSET(sp, O_SECURE)) {
ex_wemsg(sp, cmdp->cmd->name, EXM_SECURE_F);
return (1);
}
/* Expand the argument. */
for (++p; *p && cmdskip(*p); ++p);
if (*p == '\0') {
ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
return (1);
}
if (argv_exp1(sp, cmdp, p, STRLEN(p), 1))
return (1);
/* Set the last bang command */
exp = EXP(sp);
free(exp->lastbcomm);
exp->lastbcomm = v_wstrdup(sp, cmdp->argv[1]->bp,
cmdp->argv[1]->len);
/*
* Historically, vi waited after a write filter even if there
* wasn't any output from the command. People complained when
* nvi waited only if there was output, wanting the visual cue
* that the program hadn't written anything.
*/
F_SET(sp, SC_EX_WAIT_YES);
/*
* !!!
* Ignore the return cursor position, the cursor doesn't
* move.
*/
if (ex_filter(sp, cmdp, &cmdp->addr1,
&cmdp->addr2, &rm, cmdp->argv[1]->bp, FILTER_WRITE))
return (1);
/* 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");
return (0);
}
/* Set the FS_ALL flag if we're writing the entire file. */
if (cmdp->addr1.lno <= 1 && !db_exist(sp, cmdp->addr2.lno + 1))
LF_SET(FS_ALL);
/* If "write >>" it's an append to a file. */
if (cmdp->argc != 0 && cmd != XIT && p[0] == '>' && p[1] == '>') {
LF_SET(FS_APPEND);
/* Skip ">>" and whitespace. */
for (p += 2; *p && cmdskip(*p); ++p);
}
/* If no other arguments, just write the file back. */
if (cmdp->argc == 0 || *p == '\0')
return (file_write(sp,
&cmdp->addr1, &cmdp->addr2, NULL, flags));
/* Build an argv so we get an argument count and file expansion. */
if (argv_exp2(sp, cmdp, p, STRLEN(p)))
return (1);
/*
* 0 args: impossible.
* 1 args: impossible (I hope).
* 2 args: read it.
* >2 args: object, too many args.
*
* The 1 args case depends on the argv_sexp() function refusing
* to return success without at least one non-blank character.
*/
switch (cmdp->argc) {
case 0:
case 1:
abort();
/* NOTREACHED */
case 2:
INT2CHAR(sp, cmdp->argv[1]->bp, cmdp->argv[1]->len+1,
n, nlen);
name = v_strdup(sp, n, nlen - 1);
/*
* !!!
* Historically, the read and write commands renamed
* "unnamed" files, or, if the file had a name, set
* the alternate file name.
*/
if (F_ISSET(sp->frp, FR_TMPFILE) &&
!F_ISSET(sp->frp, FR_EXNAMED)) {
if ((n = v_strdup(sp, name, nlen - 1)) != NULL) {
free(sp->frp->name);
sp->frp->name = n;
}
/*
* The file has a real name, it's no longer a
* temporary, clear the temporary file flags.
*
* !!!
* If we're writing the whole file, FR_NAMECHANGE
* will be cleared by the write routine -- this is
* historic practice.
*/
F_CLR(sp->frp, FR_TMPEXIT | FR_TMPFILE);
F_SET(sp->frp, FR_NAMECHANGE | FR_EXNAMED);
/* Notify the screen. */
(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
} else
set_alt_name(sp, name);
break;
default:
INT2CHAR(sp, p, STRLEN(p) + 1, n, nlen);
ex_emsg(sp, n, EXM_FILECOUNT);
return (1);
}
rc = file_write(sp, &cmdp->addr1, &cmdp->addr2, name, flags);
free(name);
return rc;
}
/*
* v_motion --
*
* Get resulting motion mark.
*/
static int
v_motion(
SCR *sp,
VICMD *dm,
VICMD *vp,
int *mappedp)
{
VICMD motion;
size_t len;
u_long cnt;
u_int flags;
int tilde_reset, notused;
/*
* If '.' command, use the dot motion, else get the motion command.
* Clear any line motion flags, the subsequent motion isn't always
* the same, i.e. "/aaa" may or may not be a line motion.
*/
if (F_ISSET(vp, VC_ISDOT)) {
motion = *dm;
F_SET(&motion, VC_ISDOT);
F_CLR(&motion, VM_COMMASK);
} else {
memset(&motion, 0, sizeof(VICMD));
if (v_cmd(sp, NULL, &motion, vp, ¬used, mappedp) != GC_OK)
return (1);
}
/*
* A count may be provided both to the command and to the motion, in
* which case the count is multiplicative. For example, "3y4y" is the
* same as "12yy". This count is provided to the motion command and
* not to the regular function.
*/
cnt = motion.count = F_ISSET(&motion, VC_C1SET) ? motion.count : 1;
if (F_ISSET(vp, VC_C1SET)) {
motion.count *= vp->count;
F_SET(&motion, VC_C1SET);
/*
* Set flags to restore the original values of the command
* structure so dot commands can change the count values,
* e.g. "2dw" "3." deletes a total of five words.
*/
F_CLR(vp, VC_C1SET);
F_SET(vp, VC_C1RESET);
}
/*
* Some commands can be repeated to indicate the current line. In
* this case, or if the command is a "line command", set the flags
* appropriately. If not a doubled command, run the function to get
* the resulting mark.
*/
if (vp->key == motion.key) {
F_SET(vp, VM_LDOUBLE | VM_LMODE);
/* Set the origin of the command. */
vp->m_start.lno = sp->lno;
vp->m_start.cno = 0;
/*
* Set the end of the command.
*
* If the current line is missing, i.e. the file is empty,
* historic vi permitted a "cc" or "!!" command to insert
* text.
*/
vp->m_stop.lno = sp->lno + motion.count - 1;
if (db_get(sp, vp->m_stop.lno, 0, NULL, &len)) {
if (vp->m_stop.lno != 1 ||
(vp->key != 'c' && vp->key != '!')) {
v_emsg(sp, NULL, VIM_EMPTY);
return (1);
}
vp->m_stop.cno = 0;
} else
vp->m_stop.cno = len ? len - 1 : 0;
} else {
/*
* Motion commands change the underlying movement (*snarl*).
* For example, "l" is illegal at the end of a line, but "dl"
* is not. Set flags so the function knows the situation.
*/
motion.rkp = vp->kp;
/*
* XXX
* Use yank instead of creating a new motion command, it's a
* lot easier for now.
*/
if (vp->kp == &tmotion) {
tilde_reset = 1;
vp->kp = &vikeys['y'];
} else
tilde_reset = 0;
/*
* Copy the key flags into the local structure, except for the
* RCM flags -- the motion command will set the RCM flags in
* the vp structure if necessary. This means that the motion
* command is expected to determine where the cursor ends up!
* However, we save off the current RCM mask and restore it if
* it no RCM flags are set by the motion command, with a small
* modification.
*
* We replace the VM_RCM_SET flag with the VM_RCM flag. This
* is so that cursor movement doesn't set the relative position
* unless the motion command explicitly specified it. This
* appears to match historic practice, but I've never been able
* to develop a hard-and-fast rule.
*/
flags = F_ISSET(vp, VM_RCM_MASK);
if (LF_ISSET(VM_RCM_SET)) {
LF_SET(VM_RCM);
LF_CLR(VM_RCM_SET);
}
F_CLR(vp, VM_RCM_MASK);
F_SET(&motion, motion.kp->flags & ~VM_RCM_MASK);
/*
* Set the three cursor locations to the current cursor. This
* permits commands like 'j' and 'k', that are line oriented
* motions and have special cursor suck semantics when they are
* used as standalone commands, to ignore column positioning.
*/
motion.m_final.lno =
motion.m_stop.lno = motion.m_start.lno = sp->lno;
motion.m_final.cno =
motion.m_stop.cno = motion.m_start.cno = sp->cno;
/* Run the function. */
if ((motion.kp->func)(sp, &motion))
return (1);
/*
* If the current line is missing, i.e. the file is empty,
* historic vi allowed "c<motion>" or "!<motion>" to insert
* text. Otherwise fail -- most motion commands will have
* already failed, but some, e.g. G, succeed in empty files.
*/
if (!db_exist(sp, vp->m_stop.lno)) {
if (vp->m_stop.lno != 1 ||
(vp->key != 'c' && vp->key != '!')) {
v_emsg(sp, NULL, VIM_EMPTY);
return (1);
}
vp->m_stop.cno = 0;
}
/*
* XXX
* See above.
*/
if (tilde_reset)
vp->kp = &tmotion;
/*
* Copy cut buffer, line mode and cursor position information
* from the motion command structure, i.e. anything that the
* motion command can set for us. The commands can flag the
* movement as a line motion (see v_sentence) as well as set
* the VM_RCM_* flags explicitly.
*/
F_SET(vp, F_ISSET(&motion, VM_COMMASK | VM_RCM_MASK));
/*
* If the motion command set no relative motion flags, use
* the (slightly) modified previous values.
*/
if (!F_ISSET(vp, VM_RCM_MASK))
F_SET(vp, flags);
/*
* Commands can change behaviors based on the motion command
* used, for example, the ! command repeated the last bang
* command if N or n was used as the motion.
*/
vp->rkp = motion.kp;
/*
* Motion commands can reset all of the cursor information.
* If the motion is in the reverse direction, switch the
* from and to MARK's so that it's in a forward direction.
* Motions are from the from MARK to the to MARK (inclusive).
*/
if (motion.m_start.lno > motion.m_stop.lno ||
(motion.m_start.lno == motion.m_stop.lno &&
motion.m_start.cno > motion.m_stop.cno)) {
vp->m_start = motion.m_stop;
vp->m_stop = motion.m_start;
} else {
vp->m_start = motion.m_start;
vp->m_stop = motion.m_stop;
}
vp->m_final = motion.m_final;
}
/*
* If the command sets dot, save the motion structure. The motion
* count was changed above and needs to be reset, that's why this
* is done here, and not in the calling routine.
*/
if (F_ISSET(vp->kp, V_DOT)) {
*dm = motion;
dm->count = cnt;
}
return (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);
}
/*
* __wt_btcur_next --
* Move to the next record in the tree.
*/
int
__wt_btcur_next(WT_CURSOR_BTREE *cbt, bool truncating)
{
WT_CURSOR *cursor;
WT_DECL_RET;
WT_PAGE *page;
WT_SESSION_IMPL *session;
uint32_t flags;
bool newpage;
cursor = &cbt->iface;
session = (WT_SESSION_IMPL *)cbt->iface.session;
WT_STAT_CONN_INCR(session, cursor_next);
WT_STAT_DATA_INCR(session, cursor_next);
F_CLR(cursor, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);
WT_RET(__cursor_func_init(cbt, false));
/*
* If we aren't already iterating in the right direction, there's
* some setup to do.
*/
if (!F_ISSET(cbt, WT_CBT_ITERATE_NEXT))
__wt_btcur_iterate_setup(cbt);
/*
* Walk any page we're holding until the underlying call returns not-
* found. Then, move to the next page, until we reach the end of the
* file.
*/
flags = WT_READ_SKIP_INTL; /* tree walk flags */
if (truncating)
LF_SET(WT_READ_TRUNCATE);
for (newpage = false;; newpage = true) {
page = cbt->ref == NULL ? NULL : cbt->ref->page;
if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_append_next(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_append_next(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret == 0)
break;
F_CLR(cbt, WT_CBT_ITERATE_APPEND);
if (ret != WT_NOTFOUND)
break;
} else if (page != NULL) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_next(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_next(cbt, newpage);
break;
case WT_PAGE_ROW_LEAF:
ret = __cursor_row_next(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret != WT_NOTFOUND)
break;
/*
* Column-store pages may have appended entries. Handle
* it separately from the usual cursor code, it's in a
* simple format.
*/
if (page->type != WT_PAGE_ROW_LEAF &&
(cbt->ins_head = WT_COL_APPEND(page)) != NULL) {
F_SET(cbt, WT_CBT_ITERATE_APPEND);
continue;
}
}
/*
* If we saw a lot of deleted records on this page, or we went
* all the way through a page and only saw deleted records, try
* to evict the page when we release it. Otherwise repeatedly
* deleting from the beginning of a tree can have quadratic
* performance. Take care not to force eviction of pages that
* are genuinely empty, in new trees.
*/
if (page != NULL &&
(cbt->page_deleted_count > WT_BTREE_DELETE_THRESHOLD ||
(newpage && cbt->page_deleted_count > 0)))
__wt_page_evict_soon(session, cbt->ref);
cbt->page_deleted_count = 0;
WT_ERR(__wt_tree_walk(session, &cbt->ref, flags));
WT_ERR_TEST(cbt->ref == NULL, WT_NOTFOUND);
}
#ifdef HAVE_DIAGNOSTIC
if (ret == 0)
WT_ERR(__wt_cursor_key_order_check(session, cbt, true));
#endif
if (ret == 0)
F_SET(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
err: if (ret != 0)
WT_TRET(__cursor_reset(cbt));
return (ret);
}
/*
* editor --
* Main editor routine.
*
* PUBLIC: int editor __P((WIN *, int, char *[]));
*/
int
editor(WIN *wp, int argc, char **argv)
{
extern int optind;
extern char *optarg;
const char *p;
EVENT ev;
FREF *frp;
SCR *sp;
GS *gp;
size_t len;
u_int flags;
int ch, flagchk, lflag, secure, startup, readonly, rval, silent;
char *tag_f, *wsizearg, path[256];
CHAR_T *w;
size_t wlen;
gp = wp->gp;
/* Initialize the busy routine, if not defined by the screen. */
if (gp->scr_busy == NULL)
gp->scr_busy = vs_busy;
/* Initialize the message routine, if not defined by the screen. */
if (wp->scr_msg == NULL)
wp->scr_msg = vs_msg;
/* Set initial screen type and mode based on the program name. */
readonly = 0;
if (!strcmp(gp->progname, "ex") || !strcmp(gp->progname, "nex"))
LF_INIT(SC_EX);
else {
/* Nview, view are readonly. */
if (!strcmp(gp->progname, "nview") ||
!strcmp(gp->progname, "view"))
readonly = 1;
/* Vi is the default. */
LF_INIT(SC_VI);
}
/* Convert old-style arguments into new-style ones. */
if (v_obsolete(gp->progname, argv))
return (1);
/* Parse the arguments. */
flagchk = '\0';
tag_f = wsizearg = NULL;
lflag = secure = silent = 0;
startup = 1;
/* Set the file snapshot flag. */
F_SET(gp, G_SNAPSHOT);
#ifdef DEBUG
while ((ch = getopt(argc, argv, "c:D:eFlRrSsT:t:vw:")) != EOF)
#else
while ((ch = getopt(argc, argv, "c:eFlRrSst:vw:")) != EOF)
#endif
switch (ch) {
case 'c': /* Run the command. */
/*
* XXX
* We should support multiple -c options.
*/
if (gp->c_option != NULL) {
v_estr(gp->progname, 0,
"only one -c command may be specified.");
return (1);
}
gp->c_option = optarg;
break;
#ifdef DEBUG
case 'D':
switch (optarg[0]) {
case 's':
startup = 0;
break;
case 'w':
attach(gp);
break;
default:
v_estr(gp->progname, 0,
"usage: -D requires s or w argument.");
return (1);
}
break;
#endif
case 'e': /* Ex mode. */
LF_CLR(SC_VI);
LF_SET(SC_EX);
break;
case 'F': /* No snapshot. */
v_estr(gp->progname, 0,
"-F option no longer supported.");
break;
case 'l': /* Set lisp, showmatch options. */
lflag = 1;
break;
case 'R': /* Readonly. */
readonly = 1;
break;
case 'r': /* Recover. */
if (flagchk == 't') {
v_estr(gp->progname, 0,
"only one of -r and -t may be specified.");
return (1);
}
flagchk = 'r';
break;
case 'S':
secure = 1;
break;
case 's':
silent = 1;
break;
#ifdef TRACE
case 'T': /* Trace. */
(void)vtrace_init(optarg);
break;
#endif
case 't': /* Tag. */
if (flagchk == 'r') {
v_estr(gp->progname, 0,
"only one of -r and -t may be specified.");
return (1);
}
if (flagchk == 't') {
v_estr(gp->progname, 0,
"only one tag file may be specified.");
return (1);
}
flagchk = 't';
tag_f = optarg;
break;
case 'v': /* Vi mode. */
LF_CLR(SC_EX);
LF_SET(SC_VI);
break;
case 'w':
wsizearg = optarg;
break;
case '?':
default:
(void)gp->scr_usage();
return (1);
}
argc -= optind;
argv += optind;
/*
* -s option is only meaningful to ex.
*
* If not reading from a terminal, it's like -s was specified.
*/
if (silent && !LF_ISSET(SC_EX)) {
v_estr(gp->progname, 0, "-s option is only applicable to ex.");
goto err;
}
if (LF_ISSET(SC_EX) && F_ISSET(gp, G_SCRIPTED))
silent = 1;
/*
* Build and initialize the first/current screen. This is a bit
* tricky. If an error is returned, we may or may not have a
* screen structure. If we have a screen structure, put it on a
* display queue so that the error messages get displayed.
*
* !!!
* Everything we do until we go interactive is done in ex mode.
*/
if (screen_init(gp, NULL, &sp)) {
if (sp != NULL) {
CIRCLEQ_INSERT_HEAD(&wp->scrq, sp, q);
sp->wp = wp;
}
goto err;
}
F_SET(sp, SC_EX);
CIRCLEQ_INSERT_HEAD(&wp->scrq, sp, q);
sp->wp = wp;
if (v_key_init(sp)) /* Special key initialization. */
goto err;
{ int oargs[5], *oargp = oargs;
if (lflag) { /* Command-line options. */
*oargp++ = O_LISP;
*oargp++ = O_SHOWMATCH;
}
if (readonly)
*oargp++ = O_READONLY;
if (secure)
*oargp++ = O_SECURE;
*oargp = -1; /* Options initialization. */
if (opts_init(sp, oargs))
goto err;
}
if (wsizearg != NULL) {
ARGS *av[2], a, b;
(void)snprintf(path, sizeof(path), "window=%s", wsizearg);
a.bp = (CHAR_T *)path;
a.len = strlen(path);
b.bp = NULL;
b.len = 0;
av[0] = &a;
av[1] = &b;
(void)opts_set(sp, av, NULL);
}
if (silent) { /* Ex batch mode option values. */
O_CLR(sp, O_AUTOPRINT);
O_CLR(sp, O_PROMPT);
O_CLR(sp, O_VERBOSE);
O_CLR(sp, O_WARN);
F_SET(sp, SC_EX_SILENT);
}
sp->rows = O_VAL(sp, O_LINES); /* Make ex formatting work. */
sp->cols = O_VAL(sp, O_COLUMNS);
if (!silent && startup) { /* Read EXINIT, exrc files. */
if (ex_exrc(sp))
goto err;
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
/*
* List recovery files if -r specified without file arguments.
* Note, options must be initialized and startup information
* read before doing this.
*/
if (flagchk == 'r' && argv[0] == NULL) {
if (rcv_list(sp))
goto err;
if (screen_end(sp))
goto err;
goto done;
}
/*
* !!!
* Initialize the default ^D, ^U scrolling value here, after the
* user has had every opportunity to set the window option.
*
* It's historic practice that changing the value of the window
* option did not alter the default scrolling value, only giving
* a count to ^D/^U did that.
*/
sp->defscroll = (O_VAL(sp, O_WINDOW) + 1) / 2;
/*
* If we don't have a command-line option, switch into the right
* editor now, so that we position default files correctly, and
* so that any tags file file-already-locked messages are in the
* vi screen, not the ex screen.
*
* XXX
* If we have a command-line option, the error message can end
* up in the wrong place, but I think that the combination is
* unlikely.
*/
if (gp->c_option == NULL) {
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI));
}
/* Open a tag file if specified. */
if (tag_f != NULL) {
CHAR2INT(sp, tag_f, strlen(tag_f) + 1, w, wlen);
if (ex_tag_first(sp, w))
goto err;
}
/*
* Append any remaining arguments as file names. Files are recovery
* files if -r specified. If the tag option or ex startup commands
* loaded a file, then any file arguments are going to come after it.
*/
if (*argv != NULL) {
if (sp->frp != NULL) {
/* Cheat -- we know we have an extra argv slot. */
MALLOC_NOMSG(sp,
*--argv, char *, strlen(sp->frp->name) + 1);
if (*argv == NULL) {
v_estr(gp->progname, errno, NULL);
goto err;
}
(void)strcpy(*argv, sp->frp->name);
}
sp->argv = sp->cargv = argv;
F_SET(sp, SC_ARGNOFREE);
if (flagchk == 'r')
F_SET(sp, SC_ARGRECOVER);
}
/*
* __wt_btcur_prev --
* Move to the previous record in the tree.
*/
int
__wt_btcur_prev(WT_CURSOR_BTREE *cbt, int discard)
{
WT_DECL_RET;
WT_PAGE *page;
WT_SESSION_IMPL *session;
uint32_t flags;
int newpage;
session = (WT_SESSION_IMPL *)cbt->iface.session;
WT_DSTAT_INCR(session, cursor_prev);
flags = WT_TREE_SKIP_INTL | WT_TREE_PREV; /* Tree walk flags. */
if (discard)
LF_SET(WT_TREE_DISCARD);
retry: WT_RET(__cursor_func_init(cbt, 0));
__cursor_position_clear(cbt);
/*
* If we aren't already iterating in the right direction, there's
* some setup to do.
*/
if (!F_ISSET(cbt, WT_CBT_ITERATE_PREV))
__wt_btcur_iterate_setup(cbt, 0);
/*
* If this is a modification, we're about to read information from the
* page, save the write generation.
*/
page = cbt->page;
if (discard && page != NULL) {
WT_ERR(__wt_page_modify_init(session, page));
WT_ORDERED_READ(cbt->write_gen, page->modify->write_gen);
}
/*
* Walk any page we're holding until the underlying call returns not-
* found. Then, move to the previous page, until we reach the start
* of the file.
*/
for (newpage = 0;; newpage = 1) {
if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_append_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_append_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret == 0)
break;
F_CLR(cbt, WT_CBT_ITERATE_APPEND);
if (ret != WT_NOTFOUND)
break;
newpage = 1;
}
if (page != NULL) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_prev(cbt, newpage);
break;
case WT_PAGE_ROW_LEAF:
ret = __cursor_row_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret != WT_NOTFOUND)
break;
}
cbt->page = NULL;
WT_ERR(__wt_tree_walk(session, &page, flags));
WT_ERR_TEST(page == NULL, WT_NOTFOUND);
WT_ASSERT(session,
page->type != WT_PAGE_COL_INT &&
page->type != WT_PAGE_ROW_INT);
cbt->page = page;
/* Initialize the page's modification information */
if (discard) {
WT_ERR(__wt_page_modify_init(session, page));
WT_ORDERED_READ(
cbt->write_gen, page->modify->write_gen);
}
/*
* The last page in a column-store has appended entries.
* We handle it separately from the usual cursor code:
* it's only that one page and it's in a simple format.
*/
if (page->type != WT_PAGE_ROW_LEAF &&
(cbt->ins_head = WT_COL_APPEND(page)) != NULL)
F_SET(cbt, WT_CBT_ITERATE_APPEND);
}
err: if (ret == WT_RESTART)
goto retry;
WT_TRET(__cursor_func_resolve(cbt, ret));
return (ret);
}
/*
* __sync_file --
* Flush pages for a specific file.
*/
static int
__sync_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
{
WT_BTREE *btree;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_MODIFY *mod;
WT_REF *prev, *walk;
WT_TXN *txn;
uint64_t internal_bytes, internal_pages, leaf_bytes, leaf_pages;
uint64_t oldest_id, saved_pinned_id, time_start, time_stop;
uint32_t flags;
bool timer, tried_eviction;
conn = S2C(session);
btree = S2BT(session);
prev = walk = NULL;
txn = &session->txn;
tried_eviction = false;
time_start = time_stop = 0;
/* Only visit pages in cache and don't bump page read generations. */
flags = WT_READ_CACHE | WT_READ_NO_GEN;
/*
* Skip all deleted pages. For a page to be marked deleted, it must
* have been evicted from cache and marked clean. Checkpoint should
* never instantiate deleted pages: if a truncate is not visible to the
* checkpoint, the on-disk version is correct. If the truncate is
* visible, we skip over the child page when writing its parent. We
* check whether a truncate is visible in the checkpoint as part of
* reconciling internal pages (specifically in __rec_child_modify).
*/
LF_SET(WT_READ_DELETED_SKIP);
internal_bytes = leaf_bytes = 0;
internal_pages = leaf_pages = 0;
saved_pinned_id = WT_SESSION_TXN_STATE(session)->pinned_id;
timer = WT_VERBOSE_ISSET(session, WT_VERB_CHECKPOINT);
if (timer)
time_start = __wt_clock(session);
switch (syncop) {
case WT_SYNC_WRITE_LEAVES:
/*
* Write all immediately available, dirty in-cache leaf pages.
*
* Writing the leaf pages is done without acquiring a high-level
* lock, serialize so multiple threads don't walk the tree at
* the same time.
*/
if (!btree->modified)
return (0);
__wt_spin_lock(session, &btree->flush_lock);
if (!btree->modified) {
__wt_spin_unlock(session, &btree->flush_lock);
return (0);
}
/*
* Save the oldest transaction ID we need to keep around.
* Otherwise, in a busy system, we could be updating pages so
* fast that write leaves never catches up. We deliberately
* have no transaction running at this point that would keep
* the oldest ID from moving forwards as we walk the tree.
*/
oldest_id = __wt_txn_oldest_id(session);
LF_SET(WT_READ_NO_WAIT | WT_READ_SKIP_INTL);
for (;;) {
WT_ERR(__wt_tree_walk(session, &walk, flags));
if (walk == NULL)
break;
/*
* Write dirty pages if nobody beat us to it. Don't
* try to write hot pages (defined as pages that have
* been updated since the write phase leaves started):
* checkpoint will have to visit them anyway.
*/
page = walk->page;
if (__wt_page_is_modified(page) &&
WT_TXNID_LT(page->modify->update_txn, oldest_id)) {
if (txn->isolation == WT_ISO_READ_COMMITTED)
__wt_txn_get_snapshot(session);
leaf_bytes += page->memory_footprint;
++leaf_pages;
WT_ERR(__wt_reconcile(session,
walk, NULL, WT_REC_CHECKPOINT, NULL));
}
}
break;
case WT_SYNC_CHECKPOINT:
/*
* If we are flushing a file at read-committed isolation, which
* is of particular interest for flushing the metadata to make
* a schema-changing operation durable, get a transactional
* snapshot now.
*
* All changes committed up to this point should be included.
* We don't update the snapshot in between pages because the
* metadata shouldn't have many pages. Instead, read-committed
* isolation ensures that all metadata updates completed before
* the checkpoint are included.
*/
if (txn->isolation == WT_ISO_READ_COMMITTED)
__wt_txn_get_snapshot(session);
/*
* We cannot check the tree modified flag in the case of a
* checkpoint, the checkpoint code has already cleared it.
*
* Writing the leaf pages is done without acquiring a high-level
* lock, serialize so multiple threads don't walk the tree at
* the same time. We're holding the schema lock, but need the
* lower-level lock as well.
*/
__wt_spin_lock(session, &btree->flush_lock);
/*
* In the final checkpoint pass, child pages cannot be evicted
* from underneath internal pages nor can underlying blocks be
* freed until the checkpoint's block lists are stable. Also,
* we cannot split child pages into parents unless we know the
* final pass will write a consistent view of that namespace.
* Set the checkpointing flag to block such actions and wait for
* any problematic eviction or page splits to complete.
*/
WT_ASSERT(session, btree->syncing == WT_BTREE_SYNC_OFF &&
btree->sync_session == NULL);
btree->sync_session = session;
btree->syncing = WT_BTREE_SYNC_WAIT;
(void)__wt_gen_next_drain(session, WT_GEN_EVICT);
btree->syncing = WT_BTREE_SYNC_RUNNING;
/* Write all dirty in-cache pages. */
LF_SET(WT_READ_NO_EVICT);
/* Read pages with lookaside entries and evict them asap. */
LF_SET(WT_READ_LOOKASIDE | WT_READ_WONT_NEED);
for (;;) {
WT_ERR(__sync_dup_walk(session, walk, flags, &prev));
WT_ERR(__wt_tree_walk(session, &walk, flags));
if (walk == NULL)
break;
/*
* Skip clean pages, but need to make sure maximum
* transaction ID is always updated.
*/
if (!__wt_page_is_modified(walk->page)) {
if (((mod = walk->page->modify) != NULL) &&
mod->rec_max_txn > btree->rec_max_txn)
btree->rec_max_txn = mod->rec_max_txn;
if (mod != NULL &&
btree->rec_max_timestamp <
mod->rec_max_timestamp)
btree->rec_max_timestamp =
mod->rec_max_timestamp;
continue;
}
/*
* Take a local reference to the page modify structure
* now that we know the page is dirty. It needs to be
* done in this order otherwise the page modify
* structure could have been created between taking the
* reference and checking modified.
*/
page = walk->page;
/*
* Write dirty pages, if we can't skip them. If we skip
* a page, mark the tree dirty. The checkpoint marked it
* clean and we can't skip future checkpoints until this
* page is written.
*/
if (__sync_checkpoint_can_skip(session, page)) {
__wt_tree_modify_set(session);
continue;
}
if (WT_PAGE_IS_INTERNAL(page)) {
internal_bytes += page->memory_footprint;
++internal_pages;
} else {
leaf_bytes += page->memory_footprint;
++leaf_pages;
}
/*
* If the page was pulled into cache by our read, try
* to evict it now.
*
* For eviction to have a chance, we first need to move
* the walk point to the next page checkpoint will
* visit. We want to avoid this code being too special
* purpose, so try to reuse the ordinary eviction path.
*
* Regardless of whether eviction succeeds or fails,
* the walk continues from the previous location. We
* remember whether we tried eviction, and don't try
* again. Even if eviction fails (the page may stay in
* cache clean but with history that cannot be
* discarded), that is not wasted effort because
* checkpoint doesn't need to write the page again.
*/
if (!WT_PAGE_IS_INTERNAL(page) &&
page->read_gen == WT_READGEN_WONT_NEED &&
!tried_eviction) {
WT_ERR_BUSY_OK(
__wt_page_release_evict(session, walk));
walk = prev;
prev = NULL;
tried_eviction = true;
continue;
}
tried_eviction = false;
WT_ERR(__wt_reconcile(
session, walk, NULL, WT_REC_CHECKPOINT, NULL));
/*
* Update checkpoint IO tracking data if configured
* to log verbose progress messages.
*/
if (conn->ckpt_timer_start.tv_sec > 0) {
conn->ckpt_write_bytes +=
page->memory_footprint;
++conn->ckpt_write_pages;
/* Periodically log checkpoint progress. */
if (conn->ckpt_write_pages % 5000 == 0)
__wt_checkpoint_progress(
session, false);
}
}
break;
case WT_SYNC_CLOSE:
case WT_SYNC_DISCARD:
WT_ERR(__wt_illegal_value(session, syncop));
break;
}
if (timer) {
time_stop = __wt_clock(session);
__wt_verbose(session, WT_VERB_CHECKPOINT,
"__sync_file WT_SYNC_%s wrote: %" PRIu64
" leaf pages (%" PRIu64 "B), %" PRIu64
" internal pages (%" PRIu64 "B), and took %" PRIu64 "ms",
syncop == WT_SYNC_WRITE_LEAVES ?
"WRITE_LEAVES" : "CHECKPOINT",
leaf_pages, leaf_bytes, internal_pages, internal_bytes,
WT_CLOCKDIFF_MS(time_stop, time_start));
}
err: /* On error, clear any left-over tree walk. */
WT_TRET(__wt_page_release(session, walk, flags));
WT_TRET(__wt_page_release(session, prev, flags));
/*
* If we got a snapshot in order to write pages, and there was no
* snapshot active when we started, release it.
*/
if (txn->isolation == WT_ISO_READ_COMMITTED &&
saved_pinned_id == WT_TXN_NONE)
__wt_txn_release_snapshot(session);
/* Clear the checkpoint flag. */
btree->syncing = WT_BTREE_SYNC_OFF;
btree->sync_session = NULL;
__wt_spin_unlock(session, &btree->flush_lock);
/*
* Leaves are written before a checkpoint (or as part of a file close,
* before checkpointing the file). Start a flush to stable storage,
* but don't wait for it.
*/
if (ret == 0 &&
syncop == WT_SYNC_WRITE_LEAVES && F_ISSET(conn, WT_CONN_CKPT_SYNC))
WT_RET(btree->bm->sync(btree->bm, session, false));
return (ret);
}
/*
* __wt_btcur_prev --
* Move to the previous record in the tree.
*/
int
__wt_btcur_prev(WT_CURSOR_BTREE *cbt, int truncating)
{
WT_DECL_RET;
WT_PAGE *page;
WT_SESSION_IMPL *session;
uint32_t flags;
int newpage;
session = (WT_SESSION_IMPL *)cbt->iface.session;
WT_STAT_FAST_CONN_INCR(session, cursor_prev);
WT_STAT_FAST_DATA_INCR(session, cursor_prev);
flags = WT_READ_PREV | WT_READ_SKIP_INTL; /* Tree walk flags. */
if (truncating)
LF_SET(WT_READ_TRUNCATE);
WT_RET(__cursor_func_init(cbt, 0));
/*
* If we aren't already iterating in the right direction, there's
* some setup to do.
*/
if (!F_ISSET(cbt, WT_CBT_ITERATE_PREV))
__wt_btcur_iterate_setup(cbt, 0);
/*
* Walk any page we're holding until the underlying call returns not-
* found. Then, move to the previous page, until we reach the start
* of the file.
*/
page = cbt->ref == NULL ? NULL : cbt->ref->page;
for (newpage = 0;; newpage = 1) {
if (F_ISSET(cbt, WT_CBT_ITERATE_APPEND)) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_append_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_append_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret == 0)
break;
F_CLR(cbt, WT_CBT_ITERATE_APPEND);
if (ret != WT_NOTFOUND)
break;
newpage = 1;
}
if (page != NULL) {
switch (page->type) {
case WT_PAGE_COL_FIX:
ret = __cursor_fix_prev(cbt, newpage);
break;
case WT_PAGE_COL_VAR:
ret = __cursor_var_prev(cbt, newpage);
break;
case WT_PAGE_ROW_LEAF:
ret = __cursor_row_prev(cbt, newpage);
break;
WT_ILLEGAL_VALUE_ERR(session);
}
if (ret != WT_NOTFOUND)
break;
}
WT_ERR(__wt_tree_walk(session, &cbt->ref, flags));
WT_ERR_TEST(cbt->ref == NULL, WT_NOTFOUND);
page = cbt->ref->page;
WT_ASSERT(session,
page->type != WT_PAGE_COL_INT &&
page->type != WT_PAGE_ROW_INT);
/*
* The last page in a column-store has appended entries.
* We handle it separately from the usual cursor code:
* it's only that one page and it's in a simple format.
*/
if (page->type != WT_PAGE_ROW_LEAF &&
(cbt->ins_head = WT_COL_APPEND(page)) != NULL)
F_SET(cbt, WT_CBT_ITERATE_APPEND);
}
err: if (ret != 0)
WT_TRET(__cursor_error_resolve(cbt));
return (ret);
}
/*
* editor --
* Main editor routine.
*
* PUBLIC: int editor(GS *, int, char *[]);
*/
int
editor(GS *gp, int argc, char *argv[])
{
extern int optind;
extern char *optarg;
const char *p;
EVENT ev;
FREF *frp;
SCR *sp;
size_t len;
u_int flags;
int ch, flagchk, lflag, secure, startup, readonly, rval, silent;
char *tag_f, *wsizearg, path[256];
CHAR_T *w;
size_t wlen;
/* Initialize the busy routine, if not defined by the screen. */
if (gp->scr_busy == NULL)
gp->scr_busy = vs_busy;
/* Initialize the message routine, if not defined by the screen. */
if (gp->scr_msg == NULL)
gp->scr_msg = vs_msg;
gp->catd = (nl_catd)-1;
/* Common global structure initialization. */
TAILQ_INIT(gp->dq);
TAILQ_INIT(gp->hq);
SLIST_INIT(gp->ecq);
SLIST_INSERT_HEAD(gp->ecq, &gp->excmd, q);
gp->noprint = DEFAULT_NOPRINT;
/* Structures shared by screens so stored in the GS structure. */
TAILQ_INIT(gp->frefq);
TAILQ_INIT(gp->dcb_store.textq);
SLIST_INIT(gp->cutq);
SLIST_INIT(gp->seqq);
/* Set initial screen type and mode based on the program name. */
readonly = 0;
if (!strcmp(getprogname(), "ex") || !strcmp(getprogname(), "nex"))
LF_INIT(SC_EX);
else {
/* Nview, view are readonly. */
if (!strcmp(getprogname(), "nview") ||
!strcmp(getprogname(), "view"))
readonly = 1;
/* Vi is the default. */
LF_INIT(SC_VI);
}
/* Convert old-style arguments into new-style ones. */
if (v_obsolete(argv))
return (1);
/* Parse the arguments. */
flagchk = '\0';
tag_f = wsizearg = NULL;
lflag = secure = silent = 0;
startup = 1;
/* Set the file snapshot flag. */
F_SET(gp, G_SNAPSHOT);
#ifdef DEBUG
while ((ch = getopt(argc, argv, "c:D:eFlRrSsT:t:vw:")) != EOF)
#else
while ((ch = getopt(argc, argv, "c:eFlRrSst:vw:")) != EOF)
#endif
switch (ch) {
case 'c': /* Run the command. */
/*
* XXX
* We should support multiple -c options.
*/
if (gp->c_option != NULL) {
warnx("only one -c command may be specified.");
return (1);
}
gp->c_option = optarg;
break;
#ifdef DEBUG
case 'D':
switch (optarg[0]) {
case 's':
startup = 0;
break;
case 'w':
attach(gp);
break;
default:
warnx("usage: -D requires s or w argument.");
return (1);
}
break;
#endif
case 'e': /* Ex mode. */
LF_CLR(SC_VI);
LF_SET(SC_EX);
break;
case 'F': /* No snapshot. */
F_CLR(gp, G_SNAPSHOT);
break;
case 'l': /* Set lisp, showmatch options. */
lflag = 1;
break;
case 'R': /* Readonly. */
readonly = 1;
break;
case 'r': /* Recover. */
if (flagchk == 't') {
warnx("only one of -r and -t may be specified.");
return (1);
}
flagchk = 'r';
break;
case 'S':
secure = 1;
break;
case 's':
silent = 1;
break;
#ifdef DEBUG
case 'T': /* Trace. */
if ((gp->tracefp = fopen(optarg, "w")) == NULL) {
warn("%s", optarg);
goto err;
}
(void)fprintf(gp->tracefp,
"\n===\ntrace: open %s\n", optarg);
break;
#endif
case 't': /* Tag. */
if (flagchk == 'r') {
warnx("only one of -r and -t may be specified.");
return (1);
}
if (flagchk == 't') {
warnx("only one tag file may be specified.");
return (1);
}
flagchk = 't';
tag_f = optarg;
break;
case 'v': /* Vi mode. */
LF_CLR(SC_EX);
LF_SET(SC_VI);
break;
case 'w':
wsizearg = optarg;
break;
case '?':
default:
(void)gp->scr_usage();
return (1);
}
argc -= optind;
argv += optind;
/*
* -s option is only meaningful to ex.
*
* If not reading from a terminal, it's like -s was specified.
*/
if (silent && !LF_ISSET(SC_EX)) {
warnx("-s option is only applicable to ex.");
goto err;
}
if (LF_ISSET(SC_EX) && F_ISSET(gp, G_SCRIPTED))
silent = 1;
/*
* Build and initialize the first/current screen. This is a bit
* tricky. If an error is returned, we may or may not have a
* screen structure. If we have a screen structure, put it on a
* display queue so that the error messages get displayed.
*
* !!!
* Everything we do until we go interactive is done in ex mode.
*/
if (screen_init(gp, NULL, &sp)) {
if (sp != NULL)
TAILQ_INSERT_HEAD(gp->dq, sp, q);
goto err;
}
F_SET(sp, SC_EX);
TAILQ_INSERT_HEAD(gp->dq, sp, q);
if (v_key_init(sp)) /* Special key initialization. */
goto err;
{ int oargs[5], *oargp = oargs;
if (lflag) { /* Command-line options. */
*oargp++ = O_LISP;
*oargp++ = O_SHOWMATCH;
}
if (readonly)
*oargp++ = O_READONLY;
if (secure)
*oargp++ = O_SECURE;
*oargp = -1; /* Options initialization. */
if (opts_init(sp, oargs))
goto err;
}
if (wsizearg != NULL) {
ARGS *av[2], a, b;
(void)snprintf(path, sizeof(path), "window=%s", wsizearg);
a.bp = (CHAR_T *)path;
a.len = strlen(path);
b.bp = NULL;
b.len = 0;
av[0] = &a;
av[1] = &b;
(void)opts_set(sp, av, NULL);
}
if (silent) { /* Ex batch mode option values. */
O_CLR(sp, O_AUTOPRINT);
O_CLR(sp, O_PROMPT);
O_CLR(sp, O_VERBOSE);
O_CLR(sp, O_WARN);
F_SET(sp, SC_EX_SILENT);
}
sp->rows = O_VAL(sp, O_LINES); /* Make ex formatting work. */
sp->cols = O_VAL(sp, O_COLUMNS);
if (!silent && startup) { /* Read EXINIT, exrc files. */
if (ex_exrc(sp))
goto err;
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
/*
* List recovery files if -r specified without file arguments.
* Note, options must be initialized and startup information
* read before doing this.
*/
if (flagchk == 'r' && argv[0] == NULL) {
if (rcv_list(sp))
goto err;
if (screen_end(sp))
goto err;
goto done;
}
/*
* !!!
* Initialize the default ^D, ^U scrolling value here, after the
* user has had every opportunity to set the window option.
*
* It's historic practice that changing the value of the window
* option did not alter the default scrolling value, only giving
* a count to ^D/^U did that.
*/
sp->defscroll = (O_VAL(sp, O_WINDOW) + 1) / 2;
/*
* If we don't have a command-line option, switch into the right
* editor now, so that we position default files correctly, and
* so that any tags file file-already-locked messages are in the
* vi screen, not the ex screen.
*
* XXX
* If we have a command-line option, the error message can end
* up in the wrong place, but I think that the combination is
* unlikely.
*/
if (gp->c_option == NULL) {
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI));
}
/* Open a tag file if specified. */
if (tag_f != NULL) {
CHAR2INT(sp, tag_f, strlen(tag_f) + 1, w, wlen);
if (ex_tag_first(sp, w))
goto err;
}
/*
* Append any remaining arguments as file names. Files are recovery
* files if -r specified. If the tag option or ex startup commands
* loaded a file, then any file arguments are going to come after it.
*/
if (*argv != NULL) {
if (sp->frp != NULL) {
/* Cheat -- we know we have an extra argv slot. */
*--argv = strdup(sp->frp->name);
if (*argv == NULL) {
warn(NULL);
goto err;
}
}
sp->argv = sp->cargv = argv;
F_SET(sp, SC_ARGNOFREE);
if (flagchk == 'r')
F_SET(sp, SC_ARGRECOVER);
}
/*
* If the ex startup commands and or/the tag option haven't already
* created a file, create one. If no command-line files were given,
* use a temporary file.
*/
if (sp->frp == NULL) {
if (sp->argv == NULL) {
if ((frp = file_add(sp, NULL)) == NULL)
goto err;
} else {
if ((frp = file_add(sp, sp->argv[0])) == NULL)
goto err;
if (F_ISSET(sp, SC_ARGRECOVER))
F_SET(frp, FR_RECOVER);
}
if (file_init(sp, frp, NULL, 0))
goto err;
if (EXCMD_RUNNING(gp)) {
(void)ex_cmd(sp);
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
}
/*
* Check to see if we need to wait for ex. If SC_SCR_EX is set, ex
* was forced to initialize the screen during startup. We'd like to
* wait for a single character from the user, but we can't because
* we're not in raw mode. We can't switch to raw mode because the
* vi initialization will switch to xterm's alternate screen, causing
* us to lose the messages we're pausing to make sure the user read.
* So, wait for a complete line.
*/
if (F_ISSET(sp, SC_SCR_EX)) {
p = msg_cmsg(sp, CMSG_CONT_R, &len);
(void)write(STDOUT_FILENO, p, len);
for (;;) {
if (v_event_get(sp, &ev, 0, 0))
goto err;
if (ev.e_event == E_INTERRUPT ||
(ev.e_event == E_CHARACTER &&
(ev.e_value == K_CR || ev.e_value == K_NL)))
break;
(void)gp->scr_bell(sp);
}
}
/* Switch into the right editor, regardless. */
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI) | SC_STATUS_CNT);
/*
* Main edit loop. Vi handles split screens itself, we only return
* here when switching editor modes or restarting the screen.
*/
while (sp != NULL)
if (F_ISSET(sp, SC_EX) ? ex(&sp) : vi(&sp))
goto err;
done: rval = 0;
if (0)
err: rval = 1;
/* Clean out the global structure. */
v_end(gp);
return (rval);
}
/*
* __wt_conn_statistics_config --
* Set statistics configuration.
*/
int
__wt_conn_statistics_config(WT_SESSION_IMPL *session, const char *cfg[])
{
WT_CONFIG_ITEM cval, sval;
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
uint32_t flags;
int set;
conn = S2C(session);
WT_RET(__wt_config_gets(session, cfg, "statistics", &cval));
flags = 0;
set = 0;
if ((ret = __wt_config_subgets(
session, &cval, "none", &sval)) == 0 && sval.val != 0) {
flags = 0;
++set;
}
WT_RET_NOTFOUND_OK(ret);
if ((ret = __wt_config_subgets(
session, &cval, "fast", &sval)) == 0 && sval.val != 0) {
LF_SET(WT_STAT_TYPE_FAST);
++set;
}
WT_RET_NOTFOUND_OK(ret);
if ((ret = __wt_config_subgets(
session, &cval, "all", &sval)) == 0 && sval.val != 0) {
LF_SET(
WT_STAT_TYPE_ALL | WT_STAT_TYPE_CACHE_WALK |
WT_STAT_TYPE_FAST | WT_STAT_TYPE_TREE_WALK);
++set;
}
WT_RET_NOTFOUND_OK(ret);
if (set > 1)
WT_RET_MSG(session, EINVAL,
"Only one of all, fast, none configuration values should "
"be specified");
/*
* Now that we've parsed general statistics categories, process
* sub-categories.
*/
if ((ret = __wt_config_subgets(
session, &cval, "cache_walk", &sval)) == 0 && sval.val != 0)
/*
* Configuring cache walk statistics implies fast statistics.
* Keep that knowledge internal for now - it may change in the
* future.
*/
LF_SET(WT_STAT_TYPE_FAST | WT_STAT_TYPE_CACHE_WALK);
WT_RET_NOTFOUND_OK(ret);
if ((ret = __wt_config_subgets(
session, &cval, "tree_walk", &sval)) == 0 && sval.val != 0)
/*
* Configuring tree walk statistics implies fast statistics.
* Keep that knowledge internal for now - it may change in the
* future.
*/
LF_SET(WT_STAT_TYPE_FAST | WT_STAT_TYPE_TREE_WALK);
WT_RET_NOTFOUND_OK(ret);
if ((ret = __wt_config_subgets(
session, &cval, "clear", &sval)) == 0 && sval.val != 0) {
if (!LF_ISSET(WT_STAT_TYPE_ALL | WT_STAT_TYPE_CACHE_WALK |
WT_STAT_TYPE_FAST | WT_STAT_TYPE_TREE_WALK))
WT_RET_MSG(session, EINVAL,
"the value \"clear\" can only be specified if "
"statistics are enabled");
LF_SET(WT_STAT_CLEAR);
}
WT_RET_NOTFOUND_OK(ret);
/* Configuring statistics clears any existing values. */
conn->stat_flags = flags;
return (0);
}
/*
* ex_txt --
* Get lines from the terminal for ex.
*
* PUBLIC: int ex_txt(SCR *, TEXTH *, ARG_CHAR_T, u_int32_t);
*/
int
ex_txt(SCR *sp, TEXTH *tiqh, ARG_CHAR_T prompt, u_int32_t flags)
{
EVENT ev;
GS *gp;
TEXT ait, *ntp, *tp;
carat_t carat_st;
size_t cnt;
int rval;
int nochange;
rval = 0;
/*
* Get a TEXT structure with some initial buffer space, reusing the
* last one if it's big enough. (All TEXT bookkeeping fields default
* to 0 -- text_init() handles this.)
*/
if (!TAILQ_EMPTY(tiqh)) {
tp = TAILQ_FIRST(tiqh);
if (TAILQ_NEXT(tp, q) != NULL || tp->lb_len < 32) {
text_lfree(tiqh);
goto newtp;
}
tp->len = 0;
} else {
newtp: if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
goto err;
TAILQ_INSERT_HEAD(tiqh, tp, q);
}
/* Set the starting line number. */
tp->lno = sp->lno + 1;
/*
* If it's a terminal, set up autoindent, put out the prompt, and
* set it up so we know we were suspended. Otherwise, turn off
* the autoindent flag, as that requires less special casing below.
*
* XXX
* Historic practice is that ^Z suspended command mode (but, because
* it ran in cooked mode, it was unaffected by the autowrite option.)
* On restart, any "current" input was discarded, whether in insert
* mode or not, and ex was in command mode. This code matches historic
* practice, but not 'cause it's easier.
*/
gp = sp->gp;
if (F_ISSET(gp, G_SCRIPTED))
LF_CLR(TXT_AUTOINDENT);
else {
if (LF_ISSET(TXT_AUTOINDENT)) {
LF_SET(TXT_EOFCHAR);
if (v_txt_auto(sp, sp->lno, NULL, 0, tp))
goto err;
}
txt_prompt(sp, tp, prompt, flags);
}
for (carat_st = C_NOTSET, nochange = 0;;) {
if (v_event_get(sp, &ev, 0, 0))
goto err;
/* Deal with all non-character events. */
switch (ev.e_event) {
case E_CHARACTER:
break;
case E_ERR:
goto err;
case E_REPAINT:
case E_WRESIZE:
continue;
case E_EOF:
rval = 1;
/* FALLTHROUGH */
case E_INTERRUPT:
/*
* Handle EOF/SIGINT events by discarding partially
* entered text and returning. EOF returns failure,
* E_INTERRUPT returns success.
*/
goto notlast;
default:
v_event_err(sp, &ev);
goto notlast;
}
/*
* Deal with character events.
*
* Check to see if the character fits into the input buffer.
* (Use tp->len, ignore overwrite and non-printable chars.)
*/
BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
switch (ev.e_value) {
case K_CR:
/*
* !!!
* Historically, <carriage-return>'s in the command
* weren't special, so the ex parser would return an
* unknown command error message. However, if they
* terminated the command if they were in a map. I'm
* pretty sure this still isn't right, but it handles
* what I've seen so far.
*/
if (!F_ISSET(&ev.e_ch, CH_MAPPED))
goto ins_ch;
/* FALLTHROUGH */
case K_NL:
/*
* '\' can escape <carriage-return>/<newline>. We
* don't discard the backslash because we need it
* to get the <newline> through the ex parser.
*/
if (LF_ISSET(TXT_BACKSLASH) &&
tp->len != 0 && tp->lb[tp->len - 1] == '\\')
goto ins_ch;
/*
* CR returns from the ex command line.
*
* XXX
* Terminate with a nul, needed by filter.
*/
if (LF_ISSET(TXT_CR)) {
tp->lb[tp->len] = '\0';
goto done;
}
/*
* '.' may terminate text input mode; free the current
* TEXT.
*/
if (LF_ISSET(TXT_DOTTERM) && tp->len == tp->ai + 1 &&
tp->lb[tp->len - 1] == '.') {
notlast: TAILQ_REMOVE(tiqh, tp, q);
text_free(tp);
goto done;
}
/* Set up bookkeeping for the new line. */
if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
goto err;
ntp->lno = tp->lno + 1;
/*
* Reset the autoindent line value. 0^D keeps the ai
* line from changing, ^D changes the level, even if
* there were no characters in the old line. Note, if
* using the current tp structure, use the cursor as
* the length, the autoindent characters may have been
* erased.
*/
if (LF_ISSET(TXT_AUTOINDENT)) {
if (nochange) {
nochange = 0;
if (v_txt_auto(sp,
OOBLNO, &ait, ait.ai, ntp))
goto err;
free(ait.lb);
} else
if (v_txt_auto(sp,
OOBLNO, tp, tp->len, ntp))
goto err;
carat_st = C_NOTSET;
}
txt_prompt(sp, ntp, prompt, flags);
/*
* Swap old and new TEXT's, and insert the new TEXT
* into the queue.
*/
tp = ntp;
TAILQ_INSERT_TAIL(tiqh, tp, q);
break;
case K_CARAT: /* Delete autoindent chars. */
if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
carat_st = C_CARATSET;
goto ins_ch;
case K_ZERO: /* Delete autoindent chars. */
if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
carat_st = C_ZEROSET;
goto ins_ch;
case K_CNTRLD: /* Delete autoindent char. */
/*
* !!!
* Historically, the ^D command took (but then ignored)
* a count. For simplicity, we don't return it unless
* it's the first character entered. The check for len
* equal to 0 is okay, TXT_AUTOINDENT won't be set.
*/
if (LF_ISSET(TXT_CNTRLD)) {
for (cnt = 0; cnt < tp->len; ++cnt)
if (!isblank(tp->lb[cnt]))
break;
if (cnt == tp->len) {
tp->len = 1;
tp->lb[0] = ev.e_c;
tp->lb[1] = '\0';
/*
* Put out a line separator, in case
* the command fails.
*/
(void)putchar('\n');
goto done;
}
}
/*
* POSIX 1003.1b-1993, paragraph 7.1.1.9, states that
* the EOF characters are discarded if there are other
* characters to process in the line, i.e. if the EOF
* is not the first character in the line. For this
* reason, historic ex discarded the EOF characters,
* even if occurring in the middle of the input line.
* We match that historic practice.
*
* !!!
* The test for discarding in the middle of the line is
* done in the switch, because the CARAT forms are N+1,
* not N.
*
* !!!
* There's considerable magic to make the terminal code
* return the EOF character at all. See that code for
* details.
*/
if (!LF_ISSET(TXT_AUTOINDENT) || tp->len == 0)
continue;
switch (carat_st) {
case C_CARATSET: /* ^^D */
if (tp->len > tp->ai + 1)
continue;
/* Save the ai string for later. */
ait.lb = NULL;
ait.lb_len = 0;
BINC_GOTOW(sp, ait.lb, ait.lb_len, tp->ai);
MEMCPY(ait.lb, tp->lb, tp->ai);
ait.ai = ait.len = tp->ai;
carat_st = C_NOTSET;
nochange = 1;
goto leftmargin;
case C_ZEROSET: /* 0^D */
if (tp->len > tp->ai + 1)
continue;
carat_st = C_NOTSET;
leftmargin: (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
tp->ai = tp->len = 0;
break;
case C_NOTSET: /* ^D */
if (tp->len > tp->ai)
continue;
if (txt_dent(sp, tp))
goto err;
break;
default:
abort();
}
/* Clear and redisplay the line. */
(void)gp->scr_ex_adjust(sp, EX_TERM_CE);
txt_prompt(sp, tp, prompt, flags);
break;
default:
/*
* See the TXT_BEAUTIFY comment in vi/v_txt_ev.c.
*
* Silently eliminate any iscntrl() character that was
* not already handled specially, except for <tab> and
* <ff>.
*/
ins_ch: if (LF_ISSET(TXT_BEAUTIFY) && ISCNTRL(ev.e_c) &&
ev.e_value != K_FORMFEED && ev.e_value != K_TAB)
break;
tp->lb[tp->len++] = ev.e_c;
break;
}
}
/* NOTREACHED */
done: return (rval);
err:
alloc_err:
return (1);
}
/*
* __wt_open --
* Open a file handle.
*/
int
__wt_open(WT_SESSION_IMPL *session,
const char *name, WT_FS_OPEN_FILE_TYPE file_type, u_int flags, WT_FH **fhp)
{
WT_CONNECTION_IMPL *conn;
WT_DECL_RET;
WT_FH *fh;
WT_FILE_SYSTEM *file_system;
bool lock_file, open_called;
char *path;
WT_ASSERT(session, file_type != 0); /* A file type is required. */
conn = S2C(session);
file_system = conn->file_system;
fh = NULL;
open_called = false;
path = NULL;
WT_RET(__open_verbose(session, name, file_type, flags));
/* Check if the handle is already open. */
if (__handle_search(session, name, NULL, &fh)) {
*fhp = fh;
return (0);
}
/* Allocate and initialize the handle. */
WT_ERR(__wt_calloc_one(session, &fh));
WT_ERR(__wt_strdup(session, name, &fh->name));
/*
* If this is a read-only connection, open all files read-only except
* the lock file.
*
* The only file created in read-only mode is the lock file.
*/
if (F_ISSET(conn, WT_CONN_READONLY)) {
lock_file = strcmp(name, WT_SINGLETHREAD) == 0;
if (!lock_file)
LF_SET(WT_FS_OPEN_READONLY);
WT_ASSERT(session, lock_file || !LF_ISSET(WT_FS_OPEN_CREATE));
}
/* Create the path to the file. */
if (!LF_ISSET(WT_FS_OPEN_FIXED))
WT_ERR(__wt_filename(session, name, &path));
/* Call the underlying open function. */
WT_ERR(file_system->fs_open_file(file_system, &session->iface,
path == NULL ? name : path, file_type, flags, &fh->handle));
open_called = true;
WT_ERR(__fhandle_method_finalize(
session, fh->handle, LF_ISSET(WT_FS_OPEN_READONLY)));
/*
* Repeat the check for a match: if there's no match, link our newly
* created handle onto the database's list of files.
*/
if (__handle_search(session, name, fh, fhp)) {
err: if (open_called)
WT_TRET(fh->handle->close(
fh->handle, (WT_SESSION *)session));
if (fh != NULL) {
__wt_free(session, fh->name);
__wt_free(session, fh);
}
}
__wt_free(session, path);
return (ret);
}
