" netrw.vim: Handles file transfer and remote directory listing across a network
" AUTOLOAD PORTION
-" Date: Mar 09, 2006
-" Version: 79
+" Date: Mar 13, 2006
+" Version: 80
" Maintainer: Charles E Campbell, Jr <drchipNOSPAM at campbellfamily dot biz>
" GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim
" Copyright: Copyright (C) 1999-2005 Charles E. Campbell, Jr. {{{1
if &cp || exists("g:loaded_netrw")
finish
endif
-let g:loaded_netrw = "v79"
+let g:loaded_netrw = "v80"
if v:version < 700
echohl WarningMsg | echo "***netrw*** you need vim version 7.0 or later for version ".g:loaded_netrw." of netrw" | echohl None
finish
endif
let s:last_sort_by= g:netrw_sort_by
+ " set up ShellCmdPost handling. Append current buffer to browselist
+ if !exists("s:netrw_browselist")
+ let s:netrw_browselist= []
+ endif
+ if g:netrw_fastbrowse <= 1 && (empty(s:netrw_browselist) || bufnr("%") > s:netrw_browselist[-1])
+ call add(s:netrw_browselist,bufnr("%"))
+" call Decho("browselist=".string(s:netrw_browselist))
+ endif
+ if !exists("s:netrw_browser_shellcmd") && g:netrw_fastbrowse <= 1
+" call Decho("setting up local-browser shell command refresh")
+ let s:netrw_browser_shellcmd= 1
+ augroup AuNetrwShellCmd
+ au!
+ au ShellCmdPost * call s:LocalBrowseShellCmdRefresh()
+ augroup END
+ endif
+
" get the new directory name
if has("win32") || has("win95") || has("win64") || has("win16")
let b:netrw_curdir= substitute(a:dirname,'\\','/','ge')
return dirname
endfun
+" ---------------------------------------------------------------------
+" LocalBrowseShellCmdRefresh: this function is called after a user has {{{2
+" performed any shell command. The idea is to cause all local-browsing
+" buffers to be refreshed after a user has executed some shell command,
+" on the chance that s/he removed/created a file/directory with it.
+fun! s:LocalBrowseShellCmdRefresh()
+" call Dfunc("LocalBrowseShellCmdRefresh() browselist=".string(s:netrw_browselist))
+ " go through all buffers,
+ " including unlisted (which is why I can't use bufdo)
+ let curwin = winnr()
+ let ibl = 0
+ for ibuf in s:netrw_browselist
+ if bufwinnr(ibuf) == -1
+" call Decho("wiping buf#".ibuf)
+ exe "bw ".ibuf
+ call remove(s:netrw_browselist,ibl)
+" call Decho("browselist=".string(s:netrw_browselist))
+ continue
+ else
+" call Decho("refresh buf#".ibuf.'-> win#'.bufwinnr(ibuf))
+ exe bufwinnr(ibuf)."wincmd w"
+ call s:NetRefresh(s:LocalBrowseChgDir(b:netrw_curdir,'./'),1)
+ endif
+ let ibl= ibl + 1
+ endfor
+ exe curwin."wincmd w"
+
+" call Dret("LocalBrowseShellCmdRefresh")
+endfun
+
" ---------------------------------------------------------------------
" LocalBrowseRm: {{{2
fun! s:LocalBrowseRm(path) range
call search('\<'.substitute(dirfile,"^.*/","","").'\>',"w")
endif
let w:netrw_explore_mtchcnt = indx + 1
- let w:netrw_explore_bufnr = bufnr(".")
+ let w:netrw_explore_bufnr = bufnr("%")
let w:netrw_explore_line = line(".")
call s:SetupNetrwStatusLine('%f %h%m%r%=%9*%{NetrwStatusLine()}')
" call Decho("explore: mtchcnt=".w:netrw_explore_mtchcnt." bufnr=".w:netrw_explore_bufnr." line#".w:netrw_explore_line)
" let g:stlmsg=""
" if !exists("w:netrw_explore_bufnr")
" let g:stlmsg="!X<explore_bufnr>"
-" elseif w:netrw_explore_bufnr != bufnr(".")
-" let g:stlmsg="explore_bufnr!=".bufnr(".")
+" elseif w:netrw_explore_bufnr != bufnr("%")
+" let g:stlmsg="explore_bufnr!=".bufnr("%")
" endif
" if !exists("w:netrw_explore_line")
" let g:stlmsg=" !X<explore_line>"
" endif
" ^^^ NetrwStatusLine() debugging ^^^
- if !exists("w:netrw_explore_bufnr") || w:netrw_explore_bufnr != bufnr(".") || !exists("w:netrw_explore_line") || w:netrw_explore_line != line(".") || !exists("w:netrw_explore_list")
+ if !exists("w:netrw_explore_bufnr") || w:netrw_explore_bufnr != bufnr("%") || !exists("w:netrw_explore_line") || w:netrw_explore_line != line(".") || !exists("w:netrw_explore_list")
" restore user's status line
let &stl = s:netrw_users_stl
let &laststatus = s:netrw_users_ls
-*undo.txt* For Vim version 7.0aa. Last change: 2006 Feb 28
+*undo.txt* For Vim version 7.0aa. Last change: 2006 Mar 14
VIM REFERENCE MANUAL by Bram Moolenaar
1. Undo and redo commands |undo-commands|
2. Two ways of undo |undo-two-ways|
3. Undo blocks |undo-blocks|
-4. Remarks about undo |undo-remarks|
+4. Undo branches |undo-branches|
+5. Remarks about undo |undo-remarks|
==============================================================================
1. Undo and redo commands *undo-commands*
change.
==============================================================================
-4. Remarks about undo *undo-remarks*
+4. Undo branches *undo-branches*
+
+Above we only discussed one line of undo. But it is also possible to branch
+off. This happens when you undo a few changes and then make a new change.
+The undone changes become a branch. You can go to that branch with the
+following commands.
+
+What matters here is the order in which the changes are made. Undo and redo
+are not considered changes in this context. After each change you have a new
+state of the text.
+
+ *g-*
+g- Go to older text state. With a count repeat that many
+ times. {not in Vi}
+ *:ea* *:earlier*
+:earlier {count} Go to older text state {count} times.
+:earlier {N}s Go to older text state about {N} seconds before.
+:earlier {N}m Go to older text state about {N} minutes before.
+:earlier {N}h Go to older text state about {N} hours before.
+
+ *g+*
+g+ Go to newer text state. With a count repeat that many
+ times. {not in Vi}
+ *:lat* *:later*
+:later {count} Go to newer text state {count} times.
+:later {N}s Go to newer text state about {N} seconds later.
+:later {N}m Go to newer text state about {N} minutes later.
+:later {N}h Go to newer text state about {N} hours later.
+
+Note that text states will become unreachable when undo information is cleared
+for 'undolevels'.
+
+Don't be surprised when moving through time shows multiple changes to take
+place at a time. This happens when moving through the undo tree and then
+making a new change.
+
+EXAMPLE
+
+Start with this text:
+ one two three ~
+
+Delete the first word by pressing "x" three times:
+ ne two three ~
+ e two three ~
+ two three ~
+
+Now undo that by pressing "u" three times:
+ e two three ~
+ ne two three ~
+ one two three ~
+
+Delete the second word by pressing "x" three times:
+ one wo three ~
+ one o three ~
+ one three ~
+
+Now undo that by using "g-" three times:
+ one o three ~
+ one wo three ~
+ one two three ~
+
+Continue going back in time by pressing "g-" one more time:
+ two three ~
+
+You are now back in the first undo branch, after deleting "one". Repeating
+"g-" will now bring you back to the original text:
+ e two three ~
+ ne two three ~
+ one two three ~
+
+Jump to the last change with ":later 1h":
+ one three ~
+
+And back to the start again with ":earlier 1h":
+ one two three ~
+
+
+Note that using "u" and CTRL-R will not get you to all possible text states
+while repeating "g-" and "g+" does.
+
+==============================================================================
+5. Remarks about undo *undo-remarks*
The number of changes that are remembered is set with the 'undolevels' option.
If it is zero, the Vi-compatible way is always used. If it is negative no
*
* Each u_entry list contains the information for one undo or redo.
* curbuf->b_u_curhead points to the header of the last undo (the next redo),
- * or is NULL if nothing has been undone.
+ * or is NULL if nothing has been undone (end of the branch).
*
* For keeping alternate undo/redo branches the uh_alt field is used. Thus at
* each point in the list a branch may appear for an alternate to redo. The
* uh_seq field is numbered sequentially to be able to find a newer or older
* branch.
*
+ * +---------------+ +---------------+
+ * b_u_oldhead --->| u_header | | u_header |
+ * | uh_alt_next ---->| uh_alt_next ----> NULL
+ * NULL <----- uh_alt_prev |<------ uh_alt_prev |
+ * | uh_prev | | uh_prev |
+ * +-----|---------+ +-----|---------+
+ * | |
+ * V V
+ * +---------------+ +---------------+
+ * | u_header | | u_header |
+ * | uh_alt_next | | uh_alt_next |
+ * b_u_newhead --->| uh_alt_prev | | uh_alt_prev |
+ * | uh_prev | | uh_prev |
+ * +-----|---------+ +-----|---------+
+ * | |
+ * V V
+ * NULL +---------------+ +---------------+
+ * | u_header | | u_header |
+ * | uh_alt_next ---->| uh_alt_next |
+ * | uh_alt_prev |<------ uh_alt_prev |
+ * | uh_prev | | uh_prev |
+ * +-----|---------+ +-----|---------+
+ * | |
+ * etc. etc.
+ *
+ *
* All data is allocated with U_ALLOC_LINE(), it will be freed as soon as the
* buffer is unloaded.
*/
/* See below: use malloc()/free() for memory management. */
#define U_USE_MALLOC 1
+static void u_unch_branch __ARGS((u_header_T *uhp));
static u_entry_T *u_get_headentry __ARGS((void));
static void u_getbot __ARGS((void));
static int undo_allowed __ARGS((void));
static void u_doit __ARGS((int count));
static void u_undoredo __ARGS((void));
static void u_undo_end __ARGS((void));
-static void u_freelist __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
+static void u_freeheader __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
static void u_freebranch __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
static void u_freeentries __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
static void u_freeentry __ARGS((u_entry_T *, long));
}
/*
- * If we undid more than we redid, remove the entry lists before and
- * including curbuf->b_u_curhead to the alternate branch.
+ * If we undid more than we redid, move the entry lists before and
+ * including curbuf->b_u_curhead to an alternate branch.
*/
old_curhead = curbuf->b_u_curhead;
if (old_curhead != NULL)
*/
while (curbuf->b_u_numhead > p_ul && curbuf->b_u_oldhead != NULL)
{
- u_header_T *upfree = curbuf->b_u_oldhead;
+ u_header_T *uhfree = curbuf->b_u_oldhead;
/* If there is no branch only free one header. */
- if (upfree->uh_alt_next == NULL)
- u_freelist(curbuf, upfree, &old_curhead);
+ if (uhfree->uh_alt_next == NULL)
+ u_freeheader(curbuf, uhfree, &old_curhead);
else
{
/* Free the oldest alternate branch as a whole. */
- while (upfree->uh_alt_next != NULL)
- upfree = upfree->uh_alt_next;
- u_freebranch(curbuf, upfree, &old_curhead);
+ while (uhfree->uh_alt_next != NULL)
+ uhfree = uhfree->uh_alt_next;
+ u_freebranch(curbuf, uhfree, &old_curhead);
}
}
curbuf->b_u_oldhead = uhp;
}
uhp->uh_alt_prev = NULL;
- uhp->uh_seq = curbuf->b_u_seq_last++;
- curbuf->b_u_seq_cur = curbuf->b_u_seq_last;
if (curbuf->b_u_newhead != NULL)
curbuf->b_u_newhead->uh_prev = uhp;
+
+ uhp->uh_seq = curbuf->b_u_seq_last++;
+ curbuf->b_u_seq_cur = curbuf->b_u_seq_last;
+ uhp->uh_time = time(NULL);
+ curbuf->b_u_seq_time = uhp->uh_time + 1;
+
uhp->uh_walk = 0;
uhp->uh_entry = NULL;
uhp->uh_getbot_entry = NULL;
else
uhp->uh_cursor_vcol = -1;
#endif
- uhp->uh_time = time(NULL);
/* save changed and buffer empty flag for undo */
uhp->uh_flags = (curbuf->b_changed ? UH_CHANGED : 0) +
}
u_undoredo();
- curbuf->b_u_seq_cur = curbuf->b_u_curhead->uh_seq;
}
else
{
}
u_undoredo();
- curbuf->b_u_seq_cur = curbuf->b_u_curhead->uh_seq + 1;
+ ++curbuf->b_u_seq_cur;
+ ++curbuf->b_u_seq_time;
/* Advance for next redo. Set "newhead" when at the end of the
* redoable changes. */
/*
* Undo or redo over the timeline.
* When "step" is negative go back in time, otherwise goes forward in time.
+ * When "sec" is FALSE make "step" steps, when "sec" is TRUE use "step" as
+ * seconds.
*/
void
-undo_time(step)
- int step;
+undo_time(step, sec)
+ long step;
+ int sec;
{
long target;
long closest;
+ long closest_start;
+ long closest_seq = 0;
+ long val;
+ long limit;
u_header_T *uhp;
u_header_T *last;
int mark;
int nomark;
int round;
+ int dosec = sec;
+ int above = FALSE;
u_newcount = 0;
u_oldcount = 0;
* the current one also counts, thus do one less. */
if (step < 0)
{
- target = curbuf->b_u_seq_cur + step;
- closest = -1;
+ if (sec)
+ target = (long)curbuf->b_u_seq_time + step;
+ else
+ target = curbuf->b_u_seq_cur + step;
+ if (target < 0)
+ target = -1;
+ closest = -2;
}
else
{
- target = curbuf->b_u_seq_cur + step - 1;
- closest = curbuf->b_u_seq_last + 1;
+ if (sec)
+ {
+ target = curbuf->b_u_seq_time + step - 1;
+ closest = time(NULL) + 1;
+ }
+ else
+ {
+ target = curbuf->b_u_seq_cur + step - 1;
+ closest = curbuf->b_u_seq_last + 1;
+ }
+ if (target >= closest)
+ target = closest - 1;
}
+ closest_start = closest;
+ if (sec)
+ limit = curbuf->b_u_seq_time + (step > 0 ? -1 : 1);
+ else
+ limit = curbuf->b_u_seq_cur;
- /* May do this twice:
+ /*
+ * May do this twice:
* 1. Search for "target", update "closest" to the best match found.
- * 2. If "target" not found search for "closest". */
+ * 2. If "target" not found search for "closest".
+ *
+ * When using the closest time we use the sequence number in the second
+ * round, because there may be several entries with the same time.
+ */
for (round = 1; round <= 2; ++round)
{
/* Find the path from the current state to where we want to go. The
while (uhp != NULL)
{
uhp->uh_walk = mark;
- if (uhp->uh_seq == target) /* found it! */
- break;
+ val = (dosec ? uhp->uh_time : uhp->uh_seq);
- if (round == 1 && (step < 0
- ? (uhp->uh_seq < target && uhp->uh_seq > closest)
- : (uhp->uh_seq > target && uhp->uh_seq < closest)))
- closest = uhp->uh_seq;
+ if (round == 1)
+ {
+ /* Remember the header that is closest to the target.
+ * It must be at least in the right direction (checked with
+ * "limit"). When the timestamp is equal find the
+ * highest/lowest sequence number. */
+ if ((dosec && val == closest)
+ ? (step < 0
+ ? uhp->uh_seq < closest_seq
+ : uhp->uh_seq > closest_seq)
+ : (step < 0
+ ? (val < limit
+ && (closest > target
+ ? (val <= closest)
+ : (val >= closest)))
+ : (val > limit
+ && (closest < target
+ ? val >= closest
+ : val <= closest))))
+ {
+ closest = val;
+ closest_seq = uhp->uh_seq;
+ }
+ }
+
+ /* Quit searching when we found a match. But when searching for a
+ * time we need to continue looking for the best uh_seq. */
+ if (target == val && !dosec)
+ break;
/* go down in the tree if we haven't been there */
if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != nomark
if (uhp != NULL) /* found it */
break;
- if (step < 0 && closest == -1)
- {
- MSG(_("Already at oldest change"));
- return;
- }
- if (step > 0 && closest == curbuf->b_u_seq_last + 1)
+ if (closest == closest_start)
{
- MSG(_("Already at newest change"));
+ if (step < 0)
+ MSG(_("Already at oldest change"));
+ else
+ MSG(_("Already at newest change"));
return;
}
- target = closest;
+ target = closest_seq;
+ dosec = FALSE;
+ if (step < 0)
+ above = TRUE; /* stop above the header */
}
/* If we found it: Follow the path to go to where we want to be. */
uhp = curbuf->b_u_newhead;
else
{
- while (uhp->uh_alt_prev != NULL)
+ while (uhp->uh_alt_prev != NULL
+ && uhp->uh_alt_prev->uh_walk == mark)
{
uhp->uh_walk = nomark;
uhp = uhp->uh_alt_prev;
curbuf->b_u_curhead = uhp;
u_undoredo();
uhp->uh_walk = nomark; /* don't go back down here */
- curbuf->b_u_seq_cur = uhp->uh_seq;
}
/*
- * And now go down the tree, branching off where needed.
+ * And now go down the tree (redo), branching off where needed.
*/
uhp = curbuf->b_u_curhead;
for (;;)
uhp = last;
}
+ curbuf->b_u_curhead = uhp;
+ curbuf->b_u_seq_cur = uhp->uh_seq;
+ curbuf->b_u_seq_time = uhp->uh_time;
if (uhp->uh_walk != mark)
break; /* must have reached the target */
- curbuf->b_u_curhead = uhp;
+ /* Stop when going backwards in time and didn't find the exact
+ * header we were looking for. */
+ if (uhp->uh_seq == target && above)
+ break;
+
u_undoredo();
- curbuf->b_u_seq_cur = uhp->uh_seq + 1;
+ ++curbuf->b_u_seq_cur;
+ ++curbuf->b_u_seq_time;
/* Advance "curhead" to below the header we last used. If it
* becomes NULL then we need to set "newhead" to this leaf. */
visualinfo_T visualinfo;
#endif
int empty_buffer; /* buffer became empty */
+ u_header_T *curhead = curbuf->b_u_curhead;
- old_flags = curbuf->b_u_curhead->uh_flags;
+ old_flags = curhead->uh_flags;
new_flags = (curbuf->b_changed ? UH_CHANGED : 0) +
((curbuf->b_ml.ml_flags & ML_EMPTY) ? UH_EMPTYBUF : 0);
setpcmark();
curbuf->b_op_end.lnum = 0;
curbuf->b_op_end.col = 0;
- for (uep = curbuf->b_u_curhead->uh_entry; uep != NULL; uep = nuep)
+ for (uep = curhead->uh_entry; uep != NULL; uep = nuep)
{
top = uep->ue_top;
bot = uep->ue_bot;
/* If the saved cursor is somewhere in this undo block, move it to
* the remembered position. Makes "gwap" put the cursor back
* where it was. */
- lnum = curbuf->b_u_curhead->uh_cursor.lnum;
+ lnum = curhead->uh_cursor.lnum;
if (lnum >= top && lnum <= top + newsize + 1)
{
- curwin->w_cursor = curbuf->b_u_curhead->uh_cursor;
+ curwin->w_cursor = curhead->uh_cursor;
newlnum = curwin->w_cursor.lnum - 1;
}
else
newlist = uep;
}
- curbuf->b_u_curhead->uh_entry = newlist;
- curbuf->b_u_curhead->uh_flags = new_flags;
+ curhead->uh_entry = newlist;
+ curhead->uh_flags = new_flags;
if ((old_flags & UH_EMPTYBUF) && bufempty())
curbuf->b_ml.ml_flags |= ML_EMPTY;
if (old_flags & UH_CHANGED)
* restore marks from before undo/redo
*/
for (i = 0; i < NMARKS; ++i)
- if (curbuf->b_u_curhead->uh_namedm[i].lnum != 0)
+ if (curhead->uh_namedm[i].lnum != 0)
{
- curbuf->b_namedm[i] = curbuf->b_u_curhead->uh_namedm[i];
- curbuf->b_u_curhead->uh_namedm[i] = namedm[i];
+ curbuf->b_namedm[i] = curhead->uh_namedm[i];
+ curhead->uh_namedm[i] = namedm[i];
}
#ifdef FEAT_VISUAL
- if (curbuf->b_u_curhead->uh_visual.vi_start.lnum != 0)
+ if (curhead->uh_visual.vi_start.lnum != 0)
{
- curbuf->b_visual = curbuf->b_u_curhead->uh_visual;
- curbuf->b_u_curhead->uh_visual = visualinfo;
+ curbuf->b_visual = curhead->uh_visual;
+ curhead->uh_visual = visualinfo;
}
#endif
* before starting the change (for the "o" command).
* Otherwise the cursor should go to the first undone line.
*/
- if (curbuf->b_u_curhead->uh_cursor.lnum + 1 == curwin->w_cursor.lnum
+ if (curhead->uh_cursor.lnum + 1 == curwin->w_cursor.lnum
&& curwin->w_cursor.lnum > 1)
--curwin->w_cursor.lnum;
- if (curbuf->b_u_curhead->uh_cursor.lnum == curwin->w_cursor.lnum)
+ if (curhead->uh_cursor.lnum == curwin->w_cursor.lnum)
{
- curwin->w_cursor.col = curbuf->b_u_curhead->uh_cursor.col;
+ curwin->w_cursor.col = curhead->uh_cursor.col;
#ifdef FEAT_VIRTUALEDIT
- if (virtual_active() && curbuf->b_u_curhead->uh_cursor_vcol >= 0)
- coladvance((colnr_T)curbuf->b_u_curhead->uh_cursor_vcol);
+ if (virtual_active() && curhead->uh_cursor_vcol >= 0)
+ coladvance((colnr_T)curhead->uh_cursor_vcol);
else
curwin->w_cursor.coladd = 0;
#endif
/* Make sure the cursor is on an existing line and column. */
check_cursor();
+
+ /* Remember where we are for "g-" and ":earlier 10s". */
+ curbuf->b_u_seq_cur = curhead->uh_seq;
+ curbuf->b_u_seq_time = curhead->uh_time;
}
/*
void
u_unchanged(buf)
buf_T *buf;
+{
+ u_unch_branch(buf->b_u_oldhead);
+ buf->b_did_warn = FALSE;
+}
+
+ static void
+u_unch_branch(uhp)
+ u_header_T *uhp;
{
u_header_T *uh;
- for (uh = buf->b_u_newhead; uh; uh = uh->uh_next)
+ for (uh = uhp; uh != NULL; uh = uh->uh_prev)
+ {
uh->uh_flags |= UH_CHANGED;
- buf->b_did_warn = FALSE;
+ if (uh->uh_alt_next != NULL)
+ u_unch_branch(uh->uh_alt_next); /* recursive */
+ }
}
/*
* Free one header and its entry list and adjust the pointers.
*/
static void
-u_freelist(buf, uhp, uhpp)
+u_freeheader(buf, uhp, uhpp)
buf_T *buf;
u_header_T *uhp;
u_header_T **uhpp; /* if not NULL reset when freeing this header */
}
/*
- * Free an alternate branch and all following alternate branches.
+ * Free an alternate branch and any following alternate branches.
*/
static void
u_freebranch(buf, uhp, uhpp)
buf_T *buf;
{
while (buf->b_u_oldhead != NULL)
- u_freelist(buf, buf->b_u_oldhead, NULL);
+ u_freeheader(buf, buf->b_u_oldhead, NULL);
U_FREE_LINE(buf->b_u_line_ptr);
}
projects / vim / commitdiff