Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1 | " netrw.vim: Handles file transfer and remote directory listing across |
| 2 | " AUTOLOAD SECTION |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3 | " Date: Nov 03, 2017 |
| 4 | " Version: 162 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5 | " Maintainer: Charles E Campbell <NdrOchip@ScampbellPfamily.AbizM-NOSPAM> |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 6 | " GetLatestVimScripts: 1075 1 :AutoInstall: netrw.vim |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7 | " Copyright: Copyright (C) 2016 Charles E. Campbell {{{1 |
Bram Moolenaar | 572cb56 | 2005-08-05 21:35:02 +0000 | [diff] [blame] | 8 | " Permission is hereby granted to use and distribute this code, |
| 9 | " with or without modifications, provided that this copyright |
| 10 | " notice is copied with it. Like anything else that's free, |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 11 | " netrw.vim, netrwPlugin.vim, and netrwSettings.vim are provided |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12 | " *as is* and come with no warranty of any kind, either |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 13 | " expressed or implied. By using this plugin, you agree that |
| 14 | " in no event will the copyright holder be liable for any damages |
| 15 | " resulting from the use of this software. |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 16 | "redraw!|call DechoSep()|call inputsave()|call input("Press <cr> to continue")|call inputrestore() |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 17 | " |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 18 | " But be doers of the Word, and not only hearers, deluding your own selves {{{1 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 19 | " (James 1:22 RSV) |
| 20 | " =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 21 | " Load Once: {{{1 |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 22 | if &cp || exists("g:loaded_netrw") |
| 23 | finish |
| 24 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 25 | |
| 26 | " Check that vim has patches that netrw requires. |
| 27 | " Patches needed: 1557, and 213. |
| 28 | " (netrw will benefit from vim's having patch#656, too) |
| 29 | let s:needspatches=[1557,213] |
| 30 | if exists("s:needspatches") |
| 31 | for ptch in s:needspatches |
| 32 | if v:version < 704 || (v:version == 704 && !has("patch".ptch)) |
| 33 | if !exists("s:needpatch{ptch}") |
| 34 | unsilent echomsg "***sorry*** this version of netrw requires vim v7.4 with patch#".ptch |
| 35 | endif |
| 36 | let s:needpatch{ptch}= 1 |
| 37 | finish |
| 38 | endif |
| 39 | endfor |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 40 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 41 | |
| 42 | let g:loaded_netrw = "v162" |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 43 | if !exists("s:NOTE") |
| 44 | let s:NOTE = 0 |
| 45 | let s:WARNING = 1 |
| 46 | let s:ERROR = 2 |
| 47 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 48 | |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 49 | let s:keepcpo= &cpo |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 50 | setl cpo&vim |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 51 | "let g:dechofuncname= 1 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 52 | "DechoRemOn |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 53 | "call Decho("doing autoload/netrw.vim version ".g:loaded_netrw,'~'.expand("<slnum>")) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 54 | |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 55 | " ====================== |
| 56 | " Netrw Variables: {{{1 |
| 57 | " ====================== |
| 58 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 59 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 60 | " netrw#ErrorMsg: {{{2 |
| 61 | " 0=note = s:NOTE |
| 62 | " 1=warning = s:WARNING |
| 63 | " 2=error = s:ERROR |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 64 | " Usage: netrw#ErrorMsg(s:NOTE | s:WARNING | s:ERROR,"some message",error-number) |
| 65 | " netrw#ErrorMsg(s:NOTE | s:WARNING | s:ERROR,["message1","message2",...],error-number) |
| 66 | " (this function can optionally take a list of messages) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 67 | " Mar 21, 2017 : max errnum currently is 105 |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 68 | fun! netrw#ErrorMsg(level,msg,errnum) |
| 69 | " call Dfunc("netrw#ErrorMsg(level=".a:level." msg<".a:msg."> errnum=".a:errnum.") g:netrw_use_errorwindow=".g:netrw_use_errorwindow) |
| 70 | |
| 71 | if a:level < g:netrw_errorlvl |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 72 | " call Dret("netrw#ErrorMsg : suppressing level=".a:level." since g:netrw_errorlvl=".g:netrw_errorlvl) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 73 | return |
| 74 | endif |
| 75 | |
| 76 | if a:level == 1 |
| 77 | let level= "**warning** (netrw) " |
| 78 | elseif a:level == 2 |
| 79 | let level= "**error** (netrw) " |
| 80 | else |
| 81 | let level= "**note** (netrw) " |
| 82 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 83 | " call Decho("level=".level,'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 84 | |
| 85 | if g:netrw_use_errorwindow |
| 86 | " (default) netrw creates a one-line window to show error/warning |
| 87 | " messages (reliably displayed) |
| 88 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 89 | " record current window number |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 90 | let s:winBeforeErr= winnr() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 91 | " call Decho("s:winBeforeErr=".s:winBeforeErr,'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 92 | |
| 93 | " getting messages out reliably is just plain difficult! |
| 94 | " This attempt splits the current window, creating a one line window. |
| 95 | if bufexists("NetrwMessage") && bufwinnr("NetrwMessage") > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 96 | " call Decho("write to NetrwMessage buffer",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 97 | exe bufwinnr("NetrwMessage")."wincmd w" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 98 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 99 | setl ma noro |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 100 | if type(a:msg) == 3 |
| 101 | for msg in a:msg |
| 102 | NetrwKeepj call setline(line("$")+1,level.msg) |
| 103 | endfor |
| 104 | else |
| 105 | NetrwKeepj call setline(line("$")+1,level.a:msg) |
| 106 | endif |
| 107 | NetrwKeepj $ |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 108 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 109 | " call Decho("create a NetrwMessage buffer window",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 110 | bo 1split |
| 111 | sil! call s:NetrwEnew() |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 112 | sil! NetrwKeepj call s:NetrwSafeOptions() |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 113 | setl bt=nofile |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 114 | NetrwKeepj file NetrwMessage |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 115 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 116 | setl ma noro |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 117 | if type(a:msg) == 3 |
| 118 | for msg in a:msg |
| 119 | NetrwKeepj call setline(line("$")+1,level.msg) |
| 120 | endfor |
| 121 | else |
| 122 | NetrwKeepj call setline(line("$"),level.a:msg) |
| 123 | endif |
| 124 | NetrwKeepj $ |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 125 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 126 | " call Decho("wrote msg<".level.a:msg."> to NetrwMessage win#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 127 | if &fo !~ '[ta]' |
| 128 | syn clear |
| 129 | syn match netrwMesgNote "^\*\*note\*\*" |
| 130 | syn match netrwMesgWarning "^\*\*warning\*\*" |
| 131 | syn match netrwMesgError "^\*\*error\*\*" |
| 132 | hi link netrwMesgWarning WarningMsg |
| 133 | hi link netrwMesgError Error |
| 134 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 135 | " call Decho("setl noma ro bh=wipe",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 136 | setl ro nomod noma bh=wipe |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 137 | |
| 138 | else |
| 139 | " (optional) netrw will show messages using echomsg. Even if the |
| 140 | " message doesn't appear, at least it'll be recallable via :messages |
| 141 | " redraw! |
| 142 | if a:level == s:WARNING |
| 143 | echohl WarningMsg |
| 144 | elseif a:level == s:ERROR |
| 145 | echohl Error |
| 146 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 147 | |
| 148 | if type(a:msg) == 3 |
| 149 | for msg in a:msg |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 150 | unsilent echomsg level.msg |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 151 | endfor |
| 152 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 153 | unsilent echomsg level.a:msg |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 154 | endif |
| 155 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 156 | " call Decho("echomsg ***netrw*** ".a:msg,'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 157 | echohl None |
| 158 | endif |
| 159 | |
| 160 | " call Dret("netrw#ErrorMsg") |
| 161 | endfun |
| 162 | |
| 163 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 164 | " s:NetrwInit: initializes variables if they haven't been defined {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 165 | " Loosely, varname = value. |
| 166 | fun s:NetrwInit(varname,value) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 167 | " call Decho("varname<".a:varname."> value=".a:value,'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 168 | if !exists(a:varname) |
| 169 | if type(a:value) == 0 |
| 170 | exe "let ".a:varname."=".a:value |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 171 | elseif type(a:value) == 1 && a:value =~ '^[{[]' |
| 172 | exe "let ".a:varname."=".a:value |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 173 | elseif type(a:value) == 1 |
| 174 | exe "let ".a:varname."="."'".a:value."'" |
| 175 | else |
| 176 | exe "let ".a:varname."=".a:value |
| 177 | endif |
| 178 | endif |
| 179 | endfun |
| 180 | |
| 181 | " --------------------------------------------------------------------- |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 182 | " Netrw Constants: {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 183 | call s:NetrwInit("g:netrw_dirhist_cnt",0) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 184 | if !exists("s:LONGLIST") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 185 | call s:NetrwInit("s:THINLIST",0) |
| 186 | call s:NetrwInit("s:LONGLIST",1) |
| 187 | call s:NetrwInit("s:WIDELIST",2) |
| 188 | call s:NetrwInit("s:TREELIST",3) |
| 189 | call s:NetrwInit("s:MAXLIST" ,4) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 190 | endif |
| 191 | |
| 192 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 193 | " Default option values: {{{2 |
| 194 | let g:netrw_localcopycmdopt = "" |
| 195 | let g:netrw_localcopydircmdopt = "" |
| 196 | let g:netrw_localmkdiropt = "" |
| 197 | let g:netrw_localmovecmdopt = "" |
| 198 | let g:netrw_localrmdiropt = "" |
| 199 | |
| 200 | " --------------------------------------------------------------------- |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 201 | " Default values for netrw's global protocol variables {{{2 |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 202 | call s:NetrwInit("g:netrw_use_errorwindow",1) |
| 203 | |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 204 | if !exists("g:netrw_dav_cmd") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 205 | if executable("cadaver") |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 206 | let g:netrw_dav_cmd = "cadaver" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 207 | elseif executable("curl") |
| 208 | let g:netrw_dav_cmd = "curl" |
| 209 | else |
| 210 | let g:netrw_dav_cmd = "" |
| 211 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 212 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 213 | if !exists("g:netrw_fetch_cmd") |
| 214 | if executable("fetch") |
| 215 | let g:netrw_fetch_cmd = "fetch -o" |
| 216 | else |
| 217 | let g:netrw_fetch_cmd = "" |
| 218 | endif |
| 219 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 220 | if !exists("g:netrw_file_cmd") |
| 221 | if executable("elinks") |
| 222 | call s:NetrwInit("g:netrw_file_cmd","elinks") |
| 223 | elseif executable("links") |
| 224 | call s:NetrwInit("g:netrw_file_cmd","links") |
| 225 | endif |
| 226 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 227 | if !exists("g:netrw_ftp_cmd") |
| 228 | let g:netrw_ftp_cmd = "ftp" |
| 229 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 230 | let s:netrw_ftp_cmd= g:netrw_ftp_cmd |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 231 | if !exists("g:netrw_ftp_options") |
| 232 | let g:netrw_ftp_options= "-i -n" |
| 233 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 234 | if !exists("g:netrw_http_cmd") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 235 | if executable("curl") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 236 | let g:netrw_http_cmd = "curl" |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 237 | call s:NetrwInit("g:netrw_http_xcmd","-L -o") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 238 | elseif executable("wget") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 239 | let g:netrw_http_cmd = "wget" |
| 240 | call s:NetrwInit("g:netrw_http_xcmd","-q -O") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 241 | elseif executable("elinks") |
| 242 | let g:netrw_http_cmd = "elinks" |
| 243 | call s:NetrwInit("g:netrw_http_xcmd","-source >") |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 244 | elseif executable("fetch") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 245 | let g:netrw_http_cmd = "fetch" |
| 246 | call s:NetrwInit("g:netrw_http_xcmd","-o") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 247 | elseif executable("links") |
| 248 | let g:netrw_http_cmd = "links" |
| 249 | call s:NetrwInit("g:netrw_http_xcmd","-http.extra-header ".shellescape("Accept-Encoding: identity", 1)." -source >") |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 250 | else |
| 251 | let g:netrw_http_cmd = "" |
| 252 | endif |
| 253 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 254 | call s:NetrwInit("g:netrw_http_put_cmd","curl -T") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 255 | call s:NetrwInit("g:netrw_keepj","keepj") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 256 | call s:NetrwInit("g:netrw_rcp_cmd" , "rcp") |
| 257 | call s:NetrwInit("g:netrw_rsync_cmd", "rsync") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 258 | call s:NetrwInit("g:netrw_rsync_sep", "/") |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 259 | if !exists("g:netrw_scp_cmd") |
| 260 | if executable("scp") |
| 261 | call s:NetrwInit("g:netrw_scp_cmd" , "scp -q") |
| 262 | elseif executable("pscp") |
| 263 | if (has("win32") || has("win95") || has("win64") || has("win16")) && filereadable('c:\private.ppk') |
| 264 | call s:NetrwInit("g:netrw_scp_cmd", 'pscp -i c:\private.ppk') |
| 265 | else |
| 266 | call s:NetrwInit("g:netrw_scp_cmd", 'pscp -q') |
| 267 | endif |
| 268 | else |
| 269 | call s:NetrwInit("g:netrw_scp_cmd" , "scp -q") |
| 270 | endif |
| 271 | endif |
| 272 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 273 | call s:NetrwInit("g:netrw_sftp_cmd" , "sftp") |
| 274 | call s:NetrwInit("g:netrw_ssh_cmd" , "ssh") |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 275 | |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 276 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 277 | \ && exists("g:netrw_use_nt_rcp") |
| 278 | \ && g:netrw_use_nt_rcp |
| 279 | \ && executable( $SystemRoot .'/system32/rcp.exe') |
| 280 | let s:netrw_has_nt_rcp = 1 |
| 281 | let s:netrw_rcpmode = '-b' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 282 | else |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 283 | let s:netrw_has_nt_rcp = 0 |
| 284 | let s:netrw_rcpmode = '' |
| 285 | endif |
| 286 | |
| 287 | " --------------------------------------------------------------------- |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 288 | " Default values for netrw's global variables {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 289 | " Cygwin Detection ------- {{{3 |
| 290 | if !exists("g:netrw_cygwin") |
| 291 | if has("win32") || has("win95") || has("win64") || has("win16") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 292 | if has("win32unix") && &shell =~ '\%(\<bash\>\|\<zsh\>\)\%(\.exe\)\=$' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 293 | let g:netrw_cygwin= 1 |
| 294 | else |
| 295 | let g:netrw_cygwin= 0 |
| 296 | endif |
| 297 | else |
| 298 | let g:netrw_cygwin= 0 |
| 299 | endif |
| 300 | endif |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 301 | " Default values - a-c ---------- {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 302 | call s:NetrwInit("g:netrw_alto" , &sb) |
| 303 | call s:NetrwInit("g:netrw_altv" , &spr) |
| 304 | call s:NetrwInit("g:netrw_banner" , 1) |
| 305 | call s:NetrwInit("g:netrw_browse_split", 0) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 306 | call s:NetrwInit("g:netrw_bufsettings" , "noma nomod nonu nobl nowrap ro nornu") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 307 | call s:NetrwInit("g:netrw_chgwin" , -1) |
| 308 | call s:NetrwInit("g:netrw_compress" , "gzip") |
| 309 | call s:NetrwInit("g:netrw_ctags" , "ctags") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 310 | if exists("g:netrw_cursorline") && !exists("g:netrw_cursor") |
| 311 | call netrw#ErrorMsg(s:NOTE,'g:netrw_cursorline is deprecated; use g:netrw_cursor instead',77) |
| 312 | let g:netrw_cursor= g:netrw_cursorline |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 313 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 314 | call s:NetrwInit("g:netrw_cursor" , 2) |
| 315 | let s:netrw_usercul = &cursorline |
| 316 | let s:netrw_usercuc = &cursorcolumn |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 317 | call s:NetrwInit("g:netrw_cygdrive","/cygdrive") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 318 | " Default values - d-g ---------- {{{3 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 319 | call s:NetrwInit("s:didstarstar",0) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 320 | call s:NetrwInit("g:netrw_dirhist_cnt" , 0) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 321 | call s:NetrwInit("g:netrw_decompress" , '{ ".gz" : "gunzip", ".bz2" : "bunzip2", ".zip" : "unzip", ".tar" : "tar -xf", ".xz" : "unxz" }') |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 322 | call s:NetrwInit("g:netrw_dirhistmax" , 10) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 323 | call s:NetrwInit("g:netrw_errorlvl" , s:NOTE) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 324 | call s:NetrwInit("g:netrw_fastbrowse" , 1) |
| 325 | call s:NetrwInit("g:netrw_ftp_browse_reject", '^total\s\+\d\+$\|^Trying\s\+\d\+.*$\|^KERBEROS_V\d rejected\|^Security extensions not\|No such file\|: connect to address [0-9a-fA-F:]*: No route to host$') |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 326 | if !exists("g:netrw_ftp_list_cmd") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 327 | if has("unix") || (exists("g:netrw_cygwin") && g:netrw_cygwin) |
| 328 | let g:netrw_ftp_list_cmd = "ls -lF" |
| 329 | let g:netrw_ftp_timelist_cmd = "ls -tlF" |
| 330 | let g:netrw_ftp_sizelist_cmd = "ls -slF" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 331 | else |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 332 | let g:netrw_ftp_list_cmd = "dir" |
| 333 | let g:netrw_ftp_timelist_cmd = "dir" |
| 334 | let g:netrw_ftp_sizelist_cmd = "dir" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 335 | endif |
| 336 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 337 | call s:NetrwInit("g:netrw_ftpmode",'binary') |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 338 | " Default values - h-lh ---------- {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 339 | call s:NetrwInit("g:netrw_hide",1) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 340 | if !exists("g:netrw_ignorenetrc") |
| 341 | if &shell =~ '\c\<\%(cmd\|4nt\)\.exe$' |
| 342 | let g:netrw_ignorenetrc= 1 |
| 343 | else |
| 344 | let g:netrw_ignorenetrc= 0 |
| 345 | endif |
| 346 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 347 | call s:NetrwInit("g:netrw_keepdir",1) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 348 | if !exists("g:netrw_list_cmd") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 349 | if g:netrw_scp_cmd =~ '^pscp' && executable("pscp") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 350 | if (has("win32") || has("win95") || has("win64") || has("win16")) && filereadable("c:\\private.ppk") |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 351 | " provide a pscp-based listing command |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 352 | let g:netrw_scp_cmd ="pscp -i C:\\private.ppk" |
| 353 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 354 | if exists("g:netrw_list_cmd_options") |
| 355 | let g:netrw_list_cmd= g:netrw_scp_cmd." -ls USEPORT HOSTNAME: ".g:netrw_list_cmd_options |
| 356 | else |
| 357 | let g:netrw_list_cmd= g:netrw_scp_cmd." -ls USEPORT HOSTNAME:" |
| 358 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 359 | elseif executable(g:netrw_ssh_cmd) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 360 | " provide a scp-based default listing command |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 361 | if exists("g:netrw_list_cmd_options") |
| 362 | let g:netrw_list_cmd= g:netrw_ssh_cmd." USEPORT HOSTNAME ls -FLa ".g:netrw_list_cmd_options |
| 363 | else |
| 364 | let g:netrw_list_cmd= g:netrw_ssh_cmd." USEPORT HOSTNAME ls -FLa" |
| 365 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 366 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 367 | " call Decho(g:netrw_ssh_cmd." is not executable",'~'.expand("<slnum>")) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 368 | let g:netrw_list_cmd= "" |
| 369 | endif |
| 370 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 371 | call s:NetrwInit("g:netrw_list_hide","") |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 372 | " Default values - lh-lz ---------- {{{3 |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 373 | if exists("g:netrw_local_copycmd") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 374 | let g:netrw_localcopycmd= g:netrw_local_copycmd |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 375 | call netrw#ErrorMsg(s:NOTE,"g:netrw_local_copycmd is deprecated in favor of g:netrw_localcopycmd",84) |
| 376 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 377 | if !exists("g:netrw_localcmdshell") |
| 378 | let g:netrw_localcmdshell= "" |
| 379 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 380 | if !exists("g:netrw_localcopycmd") |
| 381 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 382 | if g:netrw_cygwin |
| 383 | let g:netrw_localcopycmd= "cp" |
| 384 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 385 | let g:netrw_localcopycmd = expand("$COMSPEC") |
| 386 | let g:netrw_localcopycmdopt= " /c copy" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 387 | endif |
| 388 | elseif has("unix") || has("macunix") |
| 389 | let g:netrw_localcopycmd= "cp" |
| 390 | else |
| 391 | let g:netrw_localcopycmd= "" |
| 392 | endif |
| 393 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 394 | if !exists("g:netrw_localcopydircmd") |
| 395 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 396 | if g:netrw_cygwin |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 397 | let g:netrw_localcopydircmd = "cp" |
| 398 | let g:netrw_localcopydircmdopt= " -R" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 399 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 400 | let g:netrw_localcopydircmd = expand("$COMSPEC") |
| 401 | let g:netrw_localcopydircmdopt= " /c xcopy /e /c /h /i /k" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 402 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 403 | elseif has("unix") |
| 404 | let g:netrw_localcopydircmd = "cp" |
| 405 | let g:netrw_localcopydircmdopt= " -R" |
| 406 | elseif has("macunix") |
| 407 | let g:netrw_localcopydircmd = "cp" |
| 408 | let g:netrw_localcopydircmdopt= " -R" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 409 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 410 | let g:netrw_localcopydircmd= "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 411 | endif |
| 412 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 413 | if exists("g:netrw_local_mkdir") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 414 | let g:netrw_localmkdir= g:netrw_local_mkdir |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 415 | call netrw#ErrorMsg(s:NOTE,"g:netrw_local_mkdir is deprecated in favor of g:netrw_localmkdir",87) |
| 416 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 417 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 418 | if g:netrw_cygwin |
| 419 | call s:NetrwInit("g:netrw_localmkdir","mkdir") |
| 420 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 421 | let g:netrw_localmkdir = expand("$COMSPEC") |
| 422 | let g:netrw_localmkdiropt= " /c mkdir" |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 423 | endif |
| 424 | else |
| 425 | call s:NetrwInit("g:netrw_localmkdir","mkdir") |
| 426 | endif |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 427 | call s:NetrwInit("g:netrw_remote_mkdir","mkdir") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 428 | if exists("g:netrw_local_movecmd") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 429 | let g:netrw_localmovecmd= g:netrw_local_movecmd |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 430 | call netrw#ErrorMsg(s:NOTE,"g:netrw_local_movecmd is deprecated in favor of g:netrw_localmovecmd",88) |
| 431 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 432 | if !exists("g:netrw_localmovecmd") |
| 433 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 434 | if g:netrw_cygwin |
| 435 | let g:netrw_localmovecmd= "mv" |
| 436 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 437 | let g:netrw_localmovecmd = expand("$COMSPEC") |
| 438 | let g:netrw_localmovecmdopt= " /c move" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 439 | endif |
| 440 | elseif has("unix") || has("macunix") |
| 441 | let g:netrw_localmovecmd= "mv" |
| 442 | else |
| 443 | let g:netrw_localmovecmd= "" |
| 444 | endif |
| 445 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 446 | if v:version < 704 || (v:version == 704 && !has("patch1107")) |
| 447 | " 1109 provides for delete(tmpdir,"d") which is what will be used |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 448 | if exists("g:netrw_local_rmdir") |
| 449 | let g:netrw_localrmdir= g:netrw_local_rmdir |
| 450 | call netrw#ErrorMsg(s:NOTE,"g:netrw_local_rmdir is deprecated in favor of g:netrw_localrmdir",86) |
| 451 | endif |
| 452 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 453 | if g:netrw_cygwin |
| 454 | call s:NetrwInit("g:netrw_localrmdir","rmdir") |
| 455 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 456 | let g:netrw_localrmdir = expand("$COMSPEC") |
| 457 | let g:netrw_localrmdiropt= " /c rmdir" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 458 | endif |
| 459 | else |
| 460 | call s:NetrwInit("g:netrw_localrmdir","rmdir") |
| 461 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 462 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 463 | call s:NetrwInit("g:netrw_liststyle" , s:THINLIST) |
| 464 | " sanity checks |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 465 | if g:netrw_liststyle < 0 || g:netrw_liststyle >= s:MAXLIST |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 466 | let g:netrw_liststyle= s:THINLIST |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 467 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 468 | if g:netrw_liststyle == s:LONGLIST && g:netrw_scp_cmd !~ '^pscp' |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 469 | let g:netrw_list_cmd= g:netrw_list_cmd." -l" |
| 470 | endif |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 471 | " Default values - m-r ---------- {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 472 | call s:NetrwInit("g:netrw_markfileesc" , '*./[\~') |
| 473 | call s:NetrwInit("g:netrw_maxfilenamelen", 32) |
| 474 | call s:NetrwInit("g:netrw_menu" , 1) |
| 475 | call s:NetrwInit("g:netrw_mkdir_cmd" , g:netrw_ssh_cmd." USEPORT HOSTNAME mkdir") |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 476 | call s:NetrwInit("g:netrw_mousemaps" , (exists("+mouse") && &mouse =~# '[anh]')) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 477 | call s:NetrwInit("g:netrw_retmap" , 0) |
| 478 | if has("unix") || (exists("g:netrw_cygwin") && g:netrw_cygwin) |
| 479 | call s:NetrwInit("g:netrw_chgperm" , "chmod PERM FILENAME") |
| 480 | elseif has("win32") || has("win95") || has("win64") || has("win16") |
| 481 | call s:NetrwInit("g:netrw_chgperm" , "cacls FILENAME /e /p PERM") |
| 482 | else |
| 483 | call s:NetrwInit("g:netrw_chgperm" , "chmod PERM FILENAME") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 484 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 485 | call s:NetrwInit("g:netrw_preview" , 0) |
| 486 | call s:NetrwInit("g:netrw_scpport" , "-P") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 487 | call s:NetrwInit("g:netrw_servername" , "NETRWSERVER") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 488 | call s:NetrwInit("g:netrw_sshport" , "-p") |
| 489 | call s:NetrwInit("g:netrw_rename_cmd" , g:netrw_ssh_cmd." USEPORT HOSTNAME mv") |
| 490 | call s:NetrwInit("g:netrw_rm_cmd" , g:netrw_ssh_cmd." USEPORT HOSTNAME rm") |
| 491 | call s:NetrwInit("g:netrw_rmdir_cmd" , g:netrw_ssh_cmd." USEPORT HOSTNAME rmdir") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 492 | call s:NetrwInit("g:netrw_rmf_cmd" , g:netrw_ssh_cmd." USEPORT HOSTNAME rm -f ") |
| 493 | " Default values - q-s ---------- {{{3 |
| 494 | call s:NetrwInit("g:netrw_quickhelp",0) |
| 495 | let s:QuickHelp= ["-:go up dir D:delete R:rename s:sort-by x:special", |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 496 | \ "(create new) %:file d:directory", |
| 497 | \ "(windows split&open) o:horz v:vert p:preview", |
| 498 | \ "i:style qf:file info O:obtain r:reverse", |
| 499 | \ "(marks) mf:mark file mt:set target mm:move mc:copy", |
| 500 | \ "(bookmarks) mb:make mB:delete qb:list gb:go to", |
| 501 | \ "(history) qb:list u:go up U:go down", |
| 502 | \ "(targets) mt:target Tb:use bookmark Th:use history"] |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 503 | " g:netrw_sepchr: picking a character that doesn't appear in filenames that can be used to separate priority from filename |
| 504 | call s:NetrwInit("g:netrw_sepchr" , (&enc == "euc-jp")? "\<Char-0x01>" : "\<Char-0xff>") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 505 | if !exists("g:netrw_keepj") || g:netrw_keepj == "keepj" |
| 506 | call s:NetrwInit("s:netrw_silentxfer" , (exists("g:netrw_silent") && g:netrw_silent != 0)? "sil keepj " : "keepj ") |
| 507 | else |
| 508 | call s:NetrwInit("s:netrw_silentxfer" , (exists("g:netrw_silent") && g:netrw_silent != 0)? "sil " : " ") |
| 509 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 510 | call s:NetrwInit("g:netrw_sort_by" , "name") " alternatives: date , size |
| 511 | call s:NetrwInit("g:netrw_sort_options" , "") |
| 512 | call s:NetrwInit("g:netrw_sort_direction", "normal") " alternative: reverse (z y x ...) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 513 | if !exists("g:netrw_sort_sequence") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 514 | if has("unix") |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 515 | let g:netrw_sort_sequence= '[\/]$,\<core\%(\.\d\+\)\=\>,\.h$,\.c$,\.cpp$,\~\=\*$,*,\.o$,\.obj$,\.info$,\.swp$,\.bak$,\~$' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 516 | else |
| 517 | let g:netrw_sort_sequence= '[\/]$,\.h$,\.c$,\.cpp$,*,\.o$,\.obj$,\.info$,\.swp$,\.bak$,\~$' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 518 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 519 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 520 | call s:NetrwInit("g:netrw_special_syntax" , 0) |
| 521 | call s:NetrwInit("g:netrw_ssh_browse_reject", '^total\s\+\d\+$') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 522 | call s:NetrwInit("g:netrw_suppress_gx_mesg", 1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 523 | call s:NetrwInit("g:netrw_use_noswf" , 1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 524 | call s:NetrwInit("g:netrw_sizestyle" ,"b") |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 525 | " Default values - t-w ---------- {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 526 | call s:NetrwInit("g:netrw_timefmt","%c") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 527 | if !exists("g:netrw_xstrlen") |
| 528 | if exists("g:Align_xstrlen") |
| 529 | let g:netrw_xstrlen= g:Align_xstrlen |
| 530 | elseif exists("g:drawit_xstrlen") |
| 531 | let g:netrw_xstrlen= g:drawit_xstrlen |
| 532 | elseif &enc == "latin1" || !has("multi_byte") |
| 533 | let g:netrw_xstrlen= 0 |
| 534 | else |
| 535 | let g:netrw_xstrlen= 1 |
| 536 | endif |
| 537 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 538 | call s:NetrwInit("g:NetrwTopLvlMenu","Netrw.") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 539 | call s:NetrwInit("g:netrw_win95ftp",1) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 540 | call s:NetrwInit("g:netrw_winsize",50) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 541 | call s:NetrwInit("g:netrw_wiw",1) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 542 | if g:netrw_winsize > 100|let g:netrw_winsize= 100|endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 543 | " --------------------------------------------------------------------- |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 544 | " Default values for netrw's script variables: {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 545 | call s:NetrwInit("g:netrw_fname_escape",' ?&;%') |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 546 | if has("win32") || has("win95") || has("win64") || has("win16") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 547 | call s:NetrwInit("g:netrw_glob_escape",'*?`{[]$') |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 548 | else |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 549 | call s:NetrwInit("g:netrw_glob_escape",'*[]?`{~$\') |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 550 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 551 | call s:NetrwInit("g:netrw_menu_escape",'.&? \') |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 552 | call s:NetrwInit("g:netrw_tmpfile_escape",' &;') |
| 553 | call s:NetrwInit("s:netrw_map_escape","<|\n\r\\\<C-V>\"") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 554 | if has("gui_running") && (&enc == 'utf-8' || &enc == 'utf-16' || &enc == 'ucs-4') |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 555 | let s:treedepthstring= "│ " |
| 556 | else |
| 557 | let s:treedepthstring= "| " |
| 558 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 559 | call s:NetrwInit("s:netrw_posn",'{}') |
Bram Moolenaar | 8299df9 | 2004-07-10 09:47:34 +0000 | [diff] [blame] | 560 | |
| 561 | " BufEnter event ignored by decho when following variable is true |
| 562 | " Has a side effect that doau BufReadPost doesn't work, so |
| 563 | " files read by network transfer aren't appropriately highlighted. |
| 564 | "let g:decho_bufenter = 1 "Decho |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 565 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 566 | " ====================== |
| 567 | " Netrw Initialization: {{{1 |
| 568 | " ====================== |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 569 | if v:version >= 700 && has("balloon_eval") && !exists("s:initbeval") && !exists("g:netrw_nobeval") && has("syntax") && exists("g:syntax_on") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 570 | " call Decho("installed beval events",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 571 | let &l:bexpr = "netrw#BalloonHelp()" |
| 572 | au FileType netrw setl beval |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 573 | au WinLeave * if &ft == "netrw" && exists("s:initbeval")|let &beval= s:initbeval|endif |
| 574 | au VimEnter * let s:initbeval= &beval |
| 575 | "else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 576 | " if v:version < 700 | call Decho("did not install beval events: v:version=".v:version." < 700","~".expand("<slnum>")) | endif |
| 577 | " if !has("balloon_eval") | call Decho("did not install beval events: does not have balloon_eval","~".expand("<slnum>")) | endif |
| 578 | " if exists("s:initbeval") | call Decho("did not install beval events: s:initbeval exists","~".expand("<slnum>")) | endif |
| 579 | " if exists("g:netrw_nobeval") | call Decho("did not install beval events: g:netrw_nobeval exists","~".expand("<slnum>")) | endif |
| 580 | " if !has("syntax") | call Decho("did not install beval events: does not have syntax highlighting","~".expand("<slnum>")) | endif |
| 581 | " if exists("g:syntax_on") | call Decho("did not install beval events: g:syntax_on exists","~".expand("<slnum>")) | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 582 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 583 | au WinEnter * if &ft == "netrw"|call s:NetrwInsureWinVars()|endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 584 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 585 | if g:netrw_keepj =~# "keepj" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 586 | com! -nargs=* NetrwKeepj keepj <args> |
| 587 | else |
| 588 | let g:netrw_keepj= "" |
| 589 | com! -nargs=* NetrwKeepj <args> |
| 590 | endif |
| 591 | |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 592 | " ============================== |
| 593 | " Netrw Utility Functions: {{{1 |
| 594 | " ============================== |
| 595 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 596 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 597 | " netrw#BalloonHelp: {{{2 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 598 | if v:version >= 700 && has("balloon_eval") && has("syntax") && exists("g:syntax_on") && !exists("g:netrw_nobeval") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 599 | " call Decho("loading netrw#BalloonHelp()",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 600 | fun! netrw#BalloonHelp() |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 601 | if &ft != "netrw" |
| 602 | return "" |
| 603 | endif |
| 604 | if !exists("w:netrw_bannercnt") || v:beval_lnum >= w:netrw_bannercnt || (exists("g:netrw_nobeval") && g:netrw_nobeval) |
| 605 | let mesg= "" |
| 606 | elseif v:beval_text == "Netrw" || v:beval_text == "Directory" || v:beval_text == "Listing" |
| 607 | let mesg = "i: thin-long-wide-tree gh: quick hide/unhide of dot-files qf: quick file info %:open new file" |
| 608 | elseif getline(v:beval_lnum) =~ '^"\s*/' |
| 609 | let mesg = "<cr>: edit/enter o: edit/enter in horiz window t: edit/enter in new tab v:edit/enter in vert window" |
| 610 | elseif v:beval_text == "Sorted" || v:beval_text == "by" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 611 | let mesg = 's: sort by name, time, file size, extension r: reverse sorting order mt: mark target' |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 612 | elseif v:beval_text == "Sort" || v:beval_text == "sequence" |
| 613 | let mesg = "S: edit sorting sequence" |
| 614 | elseif v:beval_text == "Hiding" || v:beval_text == "Showing" |
| 615 | let mesg = "a: hiding-showing-all ctrl-h: editing hiding list mh: hide/show by suffix" |
| 616 | elseif v:beval_text == "Quick" || v:beval_text == "Help" |
| 617 | let mesg = "Help: press <F1>" |
| 618 | elseif v:beval_text == "Copy/Move" || v:beval_text == "Tgt" |
| 619 | let mesg = "mt: mark target mc: copy marked file to target mm: move marked file to target" |
| 620 | else |
| 621 | let mesg= "" |
| 622 | endif |
| 623 | return mesg |
| 624 | endfun |
| 625 | "else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 626 | " if v:version < 700 |call Decho("did not load netrw#BalloonHelp(): vim version ".v:version." < 700 -","~".expand("<slnum>"))|endif |
| 627 | " if !has("balloon_eval") |call Decho("did not load netrw#BalloonHelp(): does not have balloon eval","~".expand("<slnum>")) |endif |
| 628 | " if !has("syntax") |call Decho("did not load netrw#BalloonHelp(): syntax disabled","~".expand("<slnum>")) |endif |
| 629 | " if !exists("g:syntax_on") |call Decho("did not load netrw#BalloonHelp(): g:syntax_on n/a","~".expand("<slnum>")) |endif |
| 630 | " if exists("g:netrw_nobeval") |call Decho("did not load netrw#BalloonHelp(): g:netrw_nobeval exists","~".expand("<slnum>")) |endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 631 | endif |
| 632 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 633 | " ------------------------------------------------------------------------ |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 634 | " netrw#Explore: launch the local browser in the directory of the current file {{{2 |
| 635 | " indx: == -1: Nexplore |
| 636 | " == -2: Pexplore |
| 637 | " == +: this is overloaded: |
| 638 | " * If Nexplore/Pexplore is in use, then this refers to the |
| 639 | " indx'th item in the w:netrw_explore_list[] of items which |
| 640 | " matched the */pattern **/pattern *//pattern **//pattern |
| 641 | " * If Hexplore or Vexplore, then this will override |
| 642 | " g:netrw_winsize to specify the qty of rows or columns the |
| 643 | " newly split window should have. |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 644 | " dosplit==0: the window will be split iff the current file has been modified and hidden not set |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 645 | " dosplit==1: the window will be split before running the local browser |
| 646 | " style == 0: Explore style == 1: Explore! |
| 647 | " == 2: Hexplore style == 3: Hexplore! |
| 648 | " == 4: Vexplore style == 5: Vexplore! |
| 649 | " == 6: Texplore |
| 650 | fun! netrw#Explore(indx,dosplit,style,...) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 651 | " call Dfunc("netrw#Explore(indx=".a:indx." dosplit=".a:dosplit." style=".a:style.",a:1<".a:1.">) &modified=".&modified." modifiable=".&modifiable." a:0=".a:0." win#".winnr()." buf#".bufnr("%")." ft=".&ft) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 652 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 653 | if !exists("b:netrw_curdir") |
| 654 | let b:netrw_curdir= getcwd() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 655 | " call Decho("set b:netrw_curdir<".b:netrw_curdir."> (used getcwd)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 656 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 657 | |
| 658 | " record current file for Rexplore's benefit |
| 659 | if &ft != "netrw" |
| 660 | let w:netrw_rexfile= expand("%:p") |
| 661 | endif |
| 662 | |
| 663 | " record current directory |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 664 | let curdir = simplify(b:netrw_curdir) |
| 665 | let curfiledir = substitute(expand("%:p"),'^\(.*[/\\]\)[^/\\]*$','\1','e') |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 666 | if !exists("g:netrw_cygwin") && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 667 | let curdir= substitute(curdir,'\','/','g') |
| 668 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 669 | " call Decho("curdir<".curdir."> curfiledir<".curfiledir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 670 | |
| 671 | " using completion, directories with spaces in their names (thanks, Bill Gates, for a truly dumb idea) |
| 672 | " will end up with backslashes here. Solution: strip off backslashes that precede white space and |
| 673 | " try Explore again. |
| 674 | if a:0 > 0 |
| 675 | " call Decho('considering retry: a:1<'.a:1.'>: '. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 676 | \ ((a:1 =~ "\\\s")? 'has backslash whitespace' : 'does not have backslash whitespace').', '. |
| 677 | \ ((filereadable(s:NetrwFile(a:1)))? 'is readable' : 'is not readable').', '. |
| 678 | \ ((isdirectory(s:NetrwFile(a:1))))? 'is a directory' : 'is not a directory', |
| 679 | \ '~'.expand("<slnum>")) |
| 680 | if a:1 =~ "\\\s" && !filereadable(s:NetrwFile(a:1)) && !isdirectory(s:NetrwFile(a:1)) |
| 681 | " call Decho("re-trying Explore with <".substitute(a:1,'\\\(\s\)','\1','g').">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 682 | call netrw#Explore(a:indx,a:dosplit,a:style,substitute(a:1,'\\\(\s\)','\1','g')) |
| 683 | " call Dret("netrw#Explore : returning from retry") |
| 684 | return |
| 685 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 686 | " call Decho("retry not needed",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 687 | endif |
| 688 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 689 | |
| 690 | " save registers |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 691 | if has("clipboard") |
| 692 | sil! let keepregstar = @* |
| 693 | sil! let keepregplus = @+ |
| 694 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 695 | sil! let keepregslash= @/ |
| 696 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 697 | " if dosplit |
| 698 | " -or- file has been modified AND file not hidden when abandoned |
| 699 | " -or- Texplore used |
| 700 | if a:dosplit || (&modified && &hidden == 0 && &bufhidden != "hide") || a:style == 6 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 701 | " call Decho("case dosplit=".a:dosplit." modified=".&modified." a:style=".a:style.": dosplit or file has been modified",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 702 | call s:SaveWinVars() |
| 703 | let winsz= g:netrw_winsize |
| 704 | if a:indx > 0 |
| 705 | let winsz= a:indx |
| 706 | endif |
| 707 | |
| 708 | if a:style == 0 " Explore, Sexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 709 | " call Decho("style=0: Explore or Sexplore",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 710 | let winsz= (winsz > 0)? (winsz*winheight(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 711 | if winsz == 0|let winsz= ""|endif |
| 712 | exe "noswapfile ".winsz."wincmd s" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 713 | " call Decho("exe noswapfile ".winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 714 | |
| 715 | elseif a:style == 1 "Explore!, Sexplore! |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 716 | " call Decho("style=1: Explore! or Sexplore!",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 717 | let winsz= (winsz > 0)? (winsz*winwidth(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 718 | if winsz == 0|let winsz= ""|endif |
| 719 | exe "keepalt noswapfile ".winsz."wincmd v" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 720 | " call Decho("exe keepalt noswapfile ".winsz."wincmd v",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 721 | |
| 722 | elseif a:style == 2 " Hexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 723 | " call Decho("style=2: Hexplore",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 724 | let winsz= (winsz > 0)? (winsz*winheight(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 725 | if winsz == 0|let winsz= ""|endif |
| 726 | exe "keepalt noswapfile bel ".winsz."wincmd s" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 727 | " call Decho("exe keepalt noswapfile bel ".winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 728 | |
| 729 | elseif a:style == 3 " Hexplore! |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 730 | " call Decho("style=3: Hexplore!",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 731 | let winsz= (winsz > 0)? (winsz*winheight(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 732 | if winsz == 0|let winsz= ""|endif |
| 733 | exe "keepalt noswapfile abo ".winsz."wincmd s" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 734 | " call Decho("exe keepalt noswapfile abo ".winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 735 | |
| 736 | elseif a:style == 4 " Vexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 737 | " call Decho("style=4: Vexplore",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 738 | let winsz= (winsz > 0)? (winsz*winwidth(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 739 | if winsz == 0|let winsz= ""|endif |
| 740 | exe "keepalt noswapfile lefta ".winsz."wincmd v" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 741 | " call Decho("exe keepalt noswapfile lefta ".winsz."wincmd v",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 742 | |
| 743 | elseif a:style == 5 " Vexplore! |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 744 | " call Decho("style=5: Vexplore!",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 745 | let winsz= (winsz > 0)? (winsz*winwidth(0))/100 : -winsz |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 746 | if winsz == 0|let winsz= ""|endif |
| 747 | exe "keepalt noswapfile rightb ".winsz."wincmd v" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 748 | " call Decho("exe keepalt noswapfile rightb ".winsz."wincmd v",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 749 | |
| 750 | elseif a:style == 6 " Texplore |
| 751 | call s:SaveBufVars() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 752 | " call Decho("style = 6: Texplore",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 753 | exe "keepalt tabnew ".fnameescape(curdir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 754 | " call Decho("exe keepalt tabnew ".fnameescape(curdir),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 755 | call s:RestoreBufVars() |
| 756 | endif |
| 757 | call s:RestoreWinVars() |
| 758 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 759 | " call Decho("case a:dosplit=".a:dosplit." AND modified=".&modified." AND a:style=".a:style." is not 6",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 760 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 761 | NetrwKeepj norm! 0 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 762 | |
| 763 | if a:0 > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 764 | " call Decho("case [a:0=".a:0."] > 0: a:1<".a:1.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 765 | if a:1 =~ '^\~' && (has("unix") || (exists("g:netrw_cygwin") && g:netrw_cygwin)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 766 | " call Decho("..case a:1<".a:1.">: starts with ~ and unix or cygwin",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 767 | let dirname= simplify(substitute(a:1,'\~',expand("$HOME"),'')) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 768 | " call Decho("..using dirname<".dirname."> (case: ~ && unix||cygwin)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 769 | elseif a:1 == '.' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 770 | " call Decho("..case a:1<".a:1.">: matches .",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 771 | let dirname= simplify(exists("b:netrw_curdir")? b:netrw_curdir : getcwd()) |
| 772 | if dirname !~ '/$' |
| 773 | let dirname= dirname."/" |
| 774 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 775 | " call Decho("..using dirname<".dirname."> (case: ".(exists("b:netrw_curdir")? "b:netrw_curdir" : "getcwd()").")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 776 | elseif a:1 =~ '\$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 777 | " call Decho("..case a:1<".a:1.">: matches ending $",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 778 | let dirname= simplify(expand(a:1)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 779 | " call Decho("..using user-specified dirname<".dirname."> with $env-var",'~'.expand("<slnum>")) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 780 | elseif a:1 !~ '^\*\{1,2}/' && a:1 !~ '^\a\{3,}://' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 781 | " call Decho("..case a:1<".a:1.">: other, not pattern or filepattern",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 782 | let dirname= simplify(a:1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 783 | " call Decho("..using user-specified dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 784 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 785 | " call Decho("..case a:1: pattern or filepattern",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 786 | let dirname= a:1 |
| 787 | endif |
| 788 | else |
| 789 | " clear explore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 790 | " call Decho("case a:0=".a:0.": clearing Explore list",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 791 | call s:NetrwClearExplore() |
| 792 | " call Dret("netrw#Explore : cleared list") |
| 793 | return |
| 794 | endif |
| 795 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 796 | " call Decho("dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 797 | if dirname =~ '\.\./\=$' |
| 798 | let dirname= simplify(fnamemodify(dirname,':p:h')) |
| 799 | elseif dirname =~ '\.\.' || dirname == '.' |
| 800 | let dirname= simplify(fnamemodify(dirname,':p')) |
| 801 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 802 | " call Decho("dirname<".dirname."> (after simplify)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 803 | |
| 804 | if dirname =~ '^\*//' |
| 805 | " starpat=1: Explore *//pattern (current directory only search for files containing pattern) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 806 | " call Decho("case starpat=1: Explore *//pattern",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 807 | let pattern= substitute(dirname,'^\*//\(.*\)$','\1','') |
| 808 | let starpat= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 809 | " call Decho("..Explore *//pat: (starpat=".starpat.") dirname<".dirname."> -> pattern<".pattern.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 810 | if &hls | let keepregslash= s:ExplorePatHls(pattern) | endif |
| 811 | |
| 812 | elseif dirname =~ '^\*\*//' |
| 813 | " starpat=2: Explore **//pattern (recursive descent search for files containing pattern) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 814 | " call Decho("case starpat=2: Explore **//pattern",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 815 | let pattern= substitute(dirname,'^\*\*//','','') |
| 816 | let starpat= 2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 817 | " call Decho("..Explore **//pat: (starpat=".starpat.") dirname<".dirname."> -> pattern<".pattern.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 818 | |
| 819 | elseif dirname =~ '/\*\*/' |
| 820 | " handle .../**/.../filepat |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 821 | " call Decho("case starpat=4: Explore .../**/.../filepat",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 822 | let prefixdir= substitute(dirname,'^\(.\{-}\)\*\*.*$','\1','') |
| 823 | if prefixdir =~ '^/' || (prefixdir =~ '^\a:/' && (has("win32") || has("win95") || has("win64") || has("win16"))) |
| 824 | let b:netrw_curdir = prefixdir |
| 825 | else |
| 826 | let b:netrw_curdir= getcwd().'/'.prefixdir |
| 827 | endif |
| 828 | let dirname= substitute(dirname,'^.\{-}\(\*\*/.*\)$','\1','') |
| 829 | let starpat= 4 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 830 | " call Decho("..pwd<".getcwd()."> dirname<".dirname.">",'~'.expand("<slnum>")) |
| 831 | " call Decho("..case Explore ../**/../filepat (starpat=".starpat.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 832 | |
| 833 | elseif dirname =~ '^\*/' |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 834 | " case starpat=3: Explore */filepat (search in current directory for filenames matching filepat) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 835 | let starpat= 3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 836 | " call Decho("case starpat=3: Explore */filepat (starpat=".starpat.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 837 | |
| 838 | elseif dirname=~ '^\*\*/' |
| 839 | " starpat=4: Explore **/filepat (recursive descent search for filenames matching filepat) |
| 840 | let starpat= 4 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 841 | " call Decho("case starpat=4: Explore **/filepat (starpat=".starpat.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 842 | |
| 843 | else |
| 844 | let starpat= 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 845 | " call Decho("case starpat=0: default",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 846 | endif |
| 847 | |
| 848 | if starpat == 0 && a:indx >= 0 |
| 849 | " [Explore Hexplore Vexplore Sexplore] [dirname] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 850 | " call Decho("case starpat==0 && a:indx=".a:indx.": dirname<".dirname.">, handles Explore Hexplore Vexplore Sexplore",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 851 | if dirname == "" |
| 852 | let dirname= curfiledir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 853 | " call Decho("..empty dirname, using current file's directory<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 854 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 855 | if dirname =~# '^scp://' || dirname =~ '^ftp://' |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 856 | call netrw#Nread(2,dirname) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 857 | else |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 858 | if dirname == "" |
| 859 | let dirname= getcwd() |
| 860 | elseif (has("win32") || has("win95") || has("win64") || has("win16")) && !g:netrw_cygwin |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 861 | " Windows : check for a drive specifier, or else for a remote share name ('\\Foo' or '//Foo', |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 862 | " depending on whether backslashes have been converted to forward slashes by earlier code). |
| 863 | if dirname !~ '^[a-zA-Z]:' && dirname !~ '^\\\\\w\+' && dirname !~ '^//\w\+' |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 864 | let dirname= b:netrw_curdir."/".dirname |
| 865 | endif |
| 866 | elseif dirname !~ '^/' |
| 867 | let dirname= b:netrw_curdir."/".dirname |
| 868 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 869 | " call Decho("..calling LocalBrowseCheck(dirname<".dirname.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 870 | call netrw#LocalBrowseCheck(dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 871 | " call Decho(" modified=".&modified." modifiable=".&modifiable." readonly=".&readonly,'~'.expand("<slnum>")) |
| 872 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 873 | endif |
| 874 | if exists("w:netrw_bannercnt") |
| 875 | " done to handle P08-Ingelrest. :Explore will _Always_ go to the line just after the banner. |
| 876 | " If one wants to return the same place in the netrw window, use :Rex instead. |
| 877 | exe w:netrw_bannercnt |
| 878 | endif |
| 879 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 880 | " call Decho("curdir<".curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 881 | " --------------------------------------------------------------------- |
| 882 | " Jan 24, 2013: not sure why the following was present. See P08-Ingelrest |
| 883 | " if has("win32") || has("win95") || has("win64") || has("win16") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 884 | " NetrwKeepj call search('\<'.substitute(curdir,'^.*[/\\]','','e').'\>','cW') |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 885 | " else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 886 | " NetrwKeepj call search('\<'.substitute(curdir,'^.*/','','e').'\>','cW') |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 887 | " endif |
| 888 | " --------------------------------------------------------------------- |
| 889 | |
| 890 | " starpat=1: Explore *//pattern (current directory only search for files containing pattern) |
| 891 | " starpat=2: Explore **//pattern (recursive descent search for files containing pattern) |
| 892 | " starpat=3: Explore */filepat (search in current directory for filenames matching filepat) |
| 893 | " starpat=4: Explore **/filepat (recursive descent search for filenames matching filepat) |
| 894 | elseif a:indx <= 0 |
| 895 | " Nexplore, Pexplore, Explore: handle starpat |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 896 | " call Decho("case a:indx<=0: Nexplore, Pexplore, <s-down>, <s-up> starpat=".starpat." a:indx=".a:indx,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 897 | if !mapcheck("<s-up>","n") && !mapcheck("<s-down>","n") && exists("b:netrw_curdir") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 898 | " call Decho("..set up <s-up> and <s-down> maps",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 899 | let s:didstarstar= 1 |
| 900 | nnoremap <buffer> <silent> <s-up> :Pexplore<cr> |
| 901 | nnoremap <buffer> <silent> <s-down> :Nexplore<cr> |
| 902 | endif |
| 903 | |
| 904 | if has("path_extra") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 905 | " call Decho("..starpat=".starpat.": has +path_extra",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 906 | if !exists("w:netrw_explore_indx") |
| 907 | let w:netrw_explore_indx= 0 |
| 908 | endif |
| 909 | |
| 910 | let indx = a:indx |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 911 | " call Decho("..starpat=".starpat.": set indx= [a:indx=".indx."]",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 912 | |
| 913 | if indx == -1 |
| 914 | " Nexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 915 | " call Decho("..case Nexplore with starpat=".starpat.": (indx=".indx.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 916 | if !exists("w:netrw_explore_list") " sanity check |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 917 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"using Nexplore or <s-down> improperly; see help for netrw-starstar",40) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 918 | if has("clipboard") |
| 919 | sil! let @* = keepregstar |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 920 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 921 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 922 | sil! let @/ = keepregslash |
| 923 | " call Dret("netrw#Explore") |
| 924 | return |
| 925 | endif |
| 926 | let indx= w:netrw_explore_indx |
| 927 | if indx < 0 | let indx= 0 | endif |
| 928 | if indx >= w:netrw_explore_listlen | let indx= w:netrw_explore_listlen - 1 | endif |
| 929 | let curfile= w:netrw_explore_list[indx] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 930 | " call Decho("....indx=".indx." curfile<".curfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 931 | while indx < w:netrw_explore_listlen && curfile == w:netrw_explore_list[indx] |
| 932 | let indx= indx + 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 933 | " call Decho("....indx=".indx." (Nexplore while loop)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 934 | endwhile |
| 935 | if indx >= w:netrw_explore_listlen | let indx= w:netrw_explore_listlen - 1 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 936 | " call Decho("....Nexplore: indx= [w:netrw_explore_indx=".w:netrw_explore_indx."]=".indx,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 937 | |
| 938 | elseif indx == -2 |
| 939 | " Pexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 940 | " call Decho("case Pexplore with starpat=".starpat.": (indx=".indx.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 941 | if !exists("w:netrw_explore_list") " sanity check |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 942 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"using Pexplore or <s-up> improperly; see help for netrw-starstar",41) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 943 | if has("clipboard") |
| 944 | sil! let @* = keepregstar |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 945 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 946 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 947 | sil! let @/ = keepregslash |
| 948 | " call Dret("netrw#Explore") |
| 949 | return |
| 950 | endif |
| 951 | let indx= w:netrw_explore_indx |
| 952 | if indx < 0 | let indx= 0 | endif |
| 953 | if indx >= w:netrw_explore_listlen | let indx= w:netrw_explore_listlen - 1 | endif |
| 954 | let curfile= w:netrw_explore_list[indx] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 955 | " call Decho("....indx=".indx." curfile<".curfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 956 | while indx >= 0 && curfile == w:netrw_explore_list[indx] |
| 957 | let indx= indx - 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 958 | " call Decho("....indx=".indx." (Pexplore while loop)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 959 | endwhile |
| 960 | if indx < 0 | let indx= 0 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 961 | " call Decho("....Pexplore: indx= [w:netrw_explore_indx=".w:netrw_explore_indx."]=".indx,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 962 | |
| 963 | else |
| 964 | " Explore -- initialize |
| 965 | " build list of files to Explore with Nexplore/Pexplore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 966 | " call Decho("..starpat=".starpat.": case Explore: initialize (indx=".indx.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 967 | NetrwKeepj keepalt call s:NetrwClearExplore() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 968 | let w:netrw_explore_indx= 0 |
| 969 | if !exists("b:netrw_curdir") |
| 970 | let b:netrw_curdir= getcwd() |
| 971 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 972 | " call Decho("....starpat=".starpat.": b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 973 | |
| 974 | " switch on starpat to build the w:netrw_explore_list of files |
| 975 | if starpat == 1 |
| 976 | " starpat=1: Explore *//pattern (current directory only search for files containing pattern) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 977 | " call Decho("..case starpat=".starpat.": build *//pattern list (curdir-only srch for files containing pattern) &hls=".&hls,'~'.expand("<slnum>")) |
| 978 | " call Decho("....pattern<".pattern.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 979 | try |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 980 | exe "NetrwKeepj noautocmd vimgrep /".pattern."/gj ".fnameescape(b:netrw_curdir)."/*" |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 981 | catch /^Vim\%((\a\+)\)\=:E480/ |
| 982 | keepalt call netrw#ErrorMsg(s:WARNING,"no match with pattern<".pattern.">",76) |
| 983 | " call Dret("netrw#Explore : unable to find pattern<".pattern.">") |
| 984 | return |
| 985 | endtry |
| 986 | let w:netrw_explore_list = s:NetrwExploreListUniq(map(getqflist(),'bufname(v:val.bufnr)')) |
| 987 | if &hls | let keepregslash= s:ExplorePatHls(pattern) | endif |
| 988 | |
| 989 | elseif starpat == 2 |
| 990 | " starpat=2: Explore **//pattern (recursive descent search for files containing pattern) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 991 | " call Decho("..case starpat=".starpat.": build **//pattern list (recursive descent files containing pattern)",'~'.expand("<slnum>")) |
| 992 | " call Decho("....pattern<".pattern.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 993 | try |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 994 | exe "sil NetrwKeepj noautocmd keepalt vimgrep /".pattern."/gj "."**/*" |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 995 | catch /^Vim\%((\a\+)\)\=:E480/ |
| 996 | keepalt call netrw#ErrorMsg(s:WARNING,'no files matched pattern<'.pattern.'>',45) |
| 997 | if &hls | let keepregslash= s:ExplorePatHls(pattern) | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 998 | if has("clipboard") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 999 | sil! let @* = keepregstar |
| 1000 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1001 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1002 | sil! let @/ = keepregslash |
| 1003 | " call Dret("netrw#Explore : no files matched pattern") |
| 1004 | return |
| 1005 | endtry |
| 1006 | let s:netrw_curdir = b:netrw_curdir |
| 1007 | let w:netrw_explore_list = getqflist() |
| 1008 | let w:netrw_explore_list = s:NetrwExploreListUniq(map(w:netrw_explore_list,'s:netrw_curdir."/".bufname(v:val.bufnr)')) |
| 1009 | if &hls | let keepregslash= s:ExplorePatHls(pattern) | endif |
| 1010 | |
| 1011 | elseif starpat == 3 |
| 1012 | " starpat=3: Explore */filepat (search in current directory for filenames matching filepat) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1013 | " call Decho("..case starpat=".starpat.": build */filepat list (curdir-only srch filenames matching filepat) &hls=".&hls,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1014 | let filepat= substitute(dirname,'^\*/','','') |
| 1015 | let filepat= substitute(filepat,'^[%#<]','\\&','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1016 | " call Decho("....b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
| 1017 | " call Decho("....filepat<".filepat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1018 | let w:netrw_explore_list= s:NetrwExploreListUniq(split(expand(b:netrw_curdir."/".filepat),'\n')) |
| 1019 | if &hls | let keepregslash= s:ExplorePatHls(filepat) | endif |
| 1020 | |
| 1021 | elseif starpat == 4 |
| 1022 | " starpat=4: Explore **/filepat (recursive descent search for filenames matching filepat) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1023 | " call Decho("..case starpat=".starpat.": build **/filepat list (recursive descent srch filenames matching filepat) &hls=".&hls,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1024 | let w:netrw_explore_list= s:NetrwExploreListUniq(split(expand(b:netrw_curdir."/".dirname),'\n')) |
| 1025 | if &hls | let keepregslash= s:ExplorePatHls(dirname) | endif |
| 1026 | endif " switch on starpat to build w:netrw_explore_list |
| 1027 | |
| 1028 | let w:netrw_explore_listlen = len(w:netrw_explore_list) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1029 | " call Decho("....w:netrw_explore_list<".string(w:netrw_explore_list).">",'~'.expand("<slnum>")) |
| 1030 | " call Decho("....w:netrw_explore_listlen=".w:netrw_explore_listlen,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1031 | |
| 1032 | if w:netrw_explore_listlen == 0 || (w:netrw_explore_listlen == 1 && w:netrw_explore_list[0] =~ '\*\*\/') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1033 | keepalt NetrwKeepj call netrw#ErrorMsg(s:WARNING,"no files matched",42) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1034 | if has("clipboard") |
| 1035 | sil! let @* = keepregstar |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1036 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1037 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1038 | sil! let @/ = keepregslash |
| 1039 | " call Dret("netrw#Explore : no files matched") |
| 1040 | return |
| 1041 | endif |
| 1042 | endif " if indx ... endif |
| 1043 | |
| 1044 | " NetrwStatusLine support - for exploring support |
| 1045 | let w:netrw_explore_indx= indx |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1046 | " call Decho("....w:netrw_explore_list<".join(w:netrw_explore_list,',')."> len=".w:netrw_explore_listlen,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1047 | |
| 1048 | " wrap the indx around, but issue a note |
| 1049 | if indx >= w:netrw_explore_listlen || indx < 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1050 | " call Decho("....wrap indx (indx=".indx." listlen=".w:netrw_explore_listlen.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1051 | let indx = (indx < 0)? ( w:netrw_explore_listlen - 1 ) : 0 |
| 1052 | let w:netrw_explore_indx= indx |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1053 | keepalt NetrwKeepj call netrw#ErrorMsg(s:NOTE,"no more files match Explore pattern",43) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1054 | endif |
| 1055 | |
| 1056 | exe "let dirfile= w:netrw_explore_list[".indx."]" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1057 | " call Decho("....dirfile=w:netrw_explore_list[indx=".indx."]= <".dirfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1058 | let newdir= substitute(dirfile,'/[^/]*$','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1059 | " call Decho("....newdir<".newdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1060 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1061 | " call Decho("....calling LocalBrowseCheck(newdir<".newdir.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1062 | call netrw#LocalBrowseCheck(newdir) |
| 1063 | if !exists("w:netrw_liststyle") |
| 1064 | let w:netrw_liststyle= g:netrw_liststyle |
| 1065 | endif |
| 1066 | if w:netrw_liststyle == s:THINLIST || w:netrw_liststyle == s:LONGLIST |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1067 | keepalt NetrwKeepj call search('^'.substitute(dirfile,"^.*/","","").'\>',"W") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1068 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1069 | keepalt NetrwKeepj call search('\<'.substitute(dirfile,"^.*/","","").'\>',"w") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1070 | endif |
| 1071 | let w:netrw_explore_mtchcnt = indx + 1 |
| 1072 | let w:netrw_explore_bufnr = bufnr("%") |
| 1073 | let w:netrw_explore_line = line(".") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1074 | keepalt NetrwKeepj call s:SetupNetrwStatusLine('%f %h%m%r%=%9*%{NetrwStatusLine()}') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1075 | " call Decho("....explore: mtchcnt=".w:netrw_explore_mtchcnt." bufnr=".w:netrw_explore_bufnr." line#".w:netrw_explore_line,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1076 | |
| 1077 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1078 | " call Decho("..your vim does not have +path_extra",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1079 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1080 | keepalt NetrwKeepj call netrw#ErrorMsg(s:WARNING,"your vim needs the +path_extra feature for Exploring with **!",44) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1081 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1082 | if has("clipboard") |
| 1083 | sil! let @* = keepregstar |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1084 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1085 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1086 | sil! let @/ = keepregslash |
| 1087 | " call Dret("netrw#Explore : missing +path_extra") |
| 1088 | return |
| 1089 | endif |
| 1090 | |
| 1091 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1092 | " call Decho("..default case: Explore newdir<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1093 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && dirname =~ '/' |
| 1094 | sil! unlet w:netrw_treedict |
| 1095 | sil! unlet w:netrw_treetop |
| 1096 | endif |
| 1097 | let newdir= dirname |
| 1098 | if !exists("b:netrw_curdir") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1099 | NetrwKeepj call netrw#LocalBrowseCheck(getcwd()) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1100 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1101 | NetrwKeepj call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,newdir)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1102 | endif |
| 1103 | endif |
| 1104 | |
| 1105 | " visual display of **/ **// */ Exploration files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1106 | " call Decho("w:netrw_explore_indx=".(exists("w:netrw_explore_indx")? w:netrw_explore_indx : "doesn't exist"),'~'.expand("<slnum>")) |
| 1107 | " call Decho("b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : "n/a").">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1108 | if exists("w:netrw_explore_indx") && exists("b:netrw_curdir") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1109 | " call Decho("s:explore_prvdir<".(exists("s:explore_prvdir")? s:explore_prvdir : "-doesn't exist-"),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1110 | if !exists("s:explore_prvdir") || s:explore_prvdir != b:netrw_curdir |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1111 | " only update match list when current directory isn't the same as before |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1112 | " call Decho("only update match list when current directory not the same as before",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1113 | let s:explore_prvdir = b:netrw_curdir |
| 1114 | let s:explore_match = "" |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1115 | let dirlen = strlen(b:netrw_curdir) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1116 | if b:netrw_curdir !~ '/$' |
| 1117 | let dirlen= dirlen + 1 |
| 1118 | endif |
| 1119 | let prvfname= "" |
| 1120 | for fname in w:netrw_explore_list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1121 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1122 | if fname =~ '^'.b:netrw_curdir |
| 1123 | if s:explore_match == "" |
| 1124 | let s:explore_match= '\<'.escape(strpart(fname,dirlen),g:netrw_markfileesc).'\>' |
| 1125 | else |
| 1126 | let s:explore_match= s:explore_match.'\|\<'.escape(strpart(fname,dirlen),g:netrw_markfileesc).'\>' |
| 1127 | endif |
| 1128 | elseif fname !~ '^/' && fname != prvfname |
| 1129 | if s:explore_match == "" |
| 1130 | let s:explore_match= '\<'.escape(fname,g:netrw_markfileesc).'\>' |
| 1131 | else |
| 1132 | let s:explore_match= s:explore_match.'\|\<'.escape(fname,g:netrw_markfileesc).'\>' |
| 1133 | endif |
| 1134 | endif |
| 1135 | let prvfname= fname |
| 1136 | endfor |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1137 | " call Decho("explore_match<".s:explore_match.">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1138 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 1139 | exe "2match netrwMarkFile /".s:explore_match."/" |
| 1140 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1141 | endif |
| 1142 | echo "<s-up>==Pexplore <s-down>==Nexplore" |
| 1143 | else |
| 1144 | 2match none |
| 1145 | if exists("s:explore_match") | unlet s:explore_match | endif |
| 1146 | if exists("s:explore_prvdir") | unlet s:explore_prvdir | endif |
| 1147 | echo " " |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1148 | " call Decho("cleared explore match list",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1149 | endif |
| 1150 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1151 | " since Explore may be used to initialize netrw's browser, |
| 1152 | " there's no danger of a late FocusGained event on initialization. |
| 1153 | " Consequently, set s:netrw_events to 2. |
| 1154 | let s:netrw_events= 2 |
| 1155 | if has("clipboard") |
| 1156 | sil! let @* = keepregstar |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1157 | sil! let @+ = keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1158 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1159 | sil! let @/ = keepregslash |
| 1160 | " call Dret("netrw#Explore : @/<".@/.">") |
| 1161 | endfun |
| 1162 | |
| 1163 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1164 | " netrw#Lexplore: toggle Explorer window, keeping it on the left of the current tab {{{2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1165 | fun! netrw#Lexplore(count,rightside,...) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1166 | " call Dfunc("netrw#Lexplore(count=".a:count." rightside=".a:rightside.",...) a:0=".a:0." ft=".&ft) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1167 | let curwin= winnr() |
| 1168 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1169 | if a:0 > 0 && a:1 != "" |
| 1170 | " if a netrw window is already on the left-side of the tab |
| 1171 | " and a directory has been specified, explore with that |
| 1172 | " directory. |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1173 | " call Decho("case has input argument(s) (a:1<".a:1.">)") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1174 | let a1 = expand(a:1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1175 | " call Decho("a:1<".a:1."> curwin#".curwin,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1176 | exe "1wincmd w" |
| 1177 | if &ft == "netrw" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1178 | " call Decho("exe Explore ".fnameescape(a:1),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1179 | exe "Explore ".fnameescape(a1) |
| 1180 | exe curwin."wincmd w" |
| 1181 | if exists("t:netrw_lexposn") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1182 | " call Decho("forgetting t:netrw_lexposn",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1183 | unlet t:netrw_lexposn |
| 1184 | endif |
| 1185 | " call Dret("netrw#Lexplore") |
| 1186 | return |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1187 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1188 | exe curwin."wincmd w" |
| 1189 | else |
| 1190 | let a1= "" |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1191 | " call Decho("no input arguments") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1192 | endif |
| 1193 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1194 | if exists("t:netrw_lexbufnr") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1195 | " check if t:netrw_lexbufnr refers to a netrw window |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1196 | let lexwinnr = bufwinnr(t:netrw_lexbufnr) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1197 | " call Decho("lexwinnr= bufwinnr(t:netrw_lexbufnr#".t:netrw_lexbufnr.")=".lexwinnr) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1198 | else |
| 1199 | let lexwinnr= 0 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1200 | " call Decho("t:netrw_lexbufnr doesn't exist") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1201 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1202 | " call Decho("lexwinnr=".lexwinnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1203 | |
| 1204 | if lexwinnr > 0 |
| 1205 | " close down netrw explorer window |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1206 | " call Decho("t:netrw_lexbufnr#".t:netrw_lexbufnr.": close down netrw window",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1207 | exe lexwinnr."wincmd w" |
| 1208 | let g:netrw_winsize = -winwidth(0) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1209 | let t:netrw_lexposn = winsaveview() |
| 1210 | " call Decho("saving posn to t:netrw_lexposn<".string(t:netrw_lexposn).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1211 | " call Decho("saving t:netrw_lexposn",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1212 | close |
| 1213 | if lexwinnr < curwin |
| 1214 | let curwin= curwin - 1 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1215 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1216 | if lexwinnr != curwin |
| 1217 | exe curwin."wincmd w" |
| 1218 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1219 | unlet t:netrw_lexbufnr |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1220 | " call Decho("unlet t:netrw_lexbufnr") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1221 | |
| 1222 | else |
| 1223 | " open netrw explorer window |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1224 | " call Decho("t:netrw_lexbufnr<n/a>: open netrw explorer window",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1225 | exe "1wincmd w" |
| 1226 | let keep_altv = g:netrw_altv |
| 1227 | let g:netrw_altv = 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1228 | if a:count != 0 |
| 1229 | let netrw_winsize = g:netrw_winsize |
| 1230 | let g:netrw_winsize = a:count |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1231 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1232 | let curfile= expand("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1233 | " call Decho("curfile<".curfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1234 | exe (a:rightside? "botright" : "topleft")." vertical ".((g:netrw_winsize > 0)? (g:netrw_winsize*winwidth(0))/100 : -g:netrw_winsize) . " new" |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1235 | " call Decho("new buf#".bufnr("%")." win#".winnr()) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1236 | if a:0 > 0 && a1 != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1237 | " call Decho("case 1: Explore ".a1,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1238 | call netrw#Explore(0,0,0,a1) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1239 | exe "Explore ".fnameescape(a1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1240 | elseif curfile =~ '^\a\{3,}://' |
| 1241 | " call Decho("case 2: Explore ".substitute(curfile,'[^/\\]*$','',''),'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1242 | call netrw#Explore(0,0,0,substitute(curfile,'[^/\\]*$','','')) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1243 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1244 | " call Decho("case 3: Explore .",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1245 | call netrw#Explore(0,0,0,".") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1246 | endif |
| 1247 | if a:count != 0 |
| 1248 | let g:netrw_winsize = netrw_winsize |
| 1249 | endif |
| 1250 | setlocal winfixwidth |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1251 | let g:netrw_altv = keep_altv |
| 1252 | let t:netrw_lexbufnr = bufnr("%") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1253 | " call Decho("let t:netrw_lexbufnr=".t:netrw_lexbufnr) |
| 1254 | " call Decho("t:netrw_lexposn".(exists("t:netrw_lexposn")? string(t:netrw_lexposn) : " n/a")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1255 | if exists("t:netrw_lexposn") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1256 | " call Decho("restoring to t:netrw_lexposn",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1257 | " call Decho("restoring posn to t:netrw_lexposn<".string(t:netrw_lexposn).">",'~'.expand("<slnum>")) |
| 1258 | call winrestview(t:netrw_lexposn) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1259 | unlet t:netrw_lexposn |
| 1260 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1261 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1262 | |
| 1263 | " set up default window for editing via <cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1264 | if exists("g:netrw_chgwin") && g:netrw_chgwin == -1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1265 | if a:rightside |
| 1266 | let g:netrw_chgwin= 1 |
| 1267 | else |
| 1268 | let g:netrw_chgwin= 2 |
| 1269 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1270 | " call Decho("let g:netrw_chgwin=".g:netrw_chgwin) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1271 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1272 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 1273 | " call Dret("netrw#Lexplore") |
| 1274 | endfun |
| 1275 | |
| 1276 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1277 | " netrw#Clean: remove netrw {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1278 | " supports :NetrwClean -- remove netrw from first directory on runtimepath |
| 1279 | " :NetrwClean! -- remove netrw from all directories on runtimepath |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1280 | fun! netrw#Clean(sys) |
| 1281 | " call Dfunc("netrw#Clean(sys=".a:sys.")") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1282 | |
| 1283 | if a:sys |
| 1284 | let choice= confirm("Remove personal and system copies of netrw?","&Yes\n&No") |
| 1285 | else |
| 1286 | let choice= confirm("Remove personal copy of netrw?","&Yes\n&No") |
| 1287 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1288 | " call Decho("choice=".choice,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1289 | let diddel= 0 |
| 1290 | let diddir= "" |
| 1291 | |
| 1292 | if choice == 1 |
| 1293 | for dir in split(&rtp,',') |
| 1294 | if filereadable(dir."/plugin/netrwPlugin.vim") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1295 | " call Decho("removing netrw-related files from ".dir,'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 1296 | if s:NetrwDelete(dir."/plugin/netrwPlugin.vim") |call netrw#ErrorMsg(1,"unable to remove ".dir."/plugin/netrwPlugin.vim",55) |endif |
| 1297 | if s:NetrwDelete(dir."/autoload/netrwFileHandlers.vim")|call netrw#ErrorMsg(1,"unable to remove ".dir."/autoload/netrwFileHandlers.vim",55)|endif |
| 1298 | if s:NetrwDelete(dir."/autoload/netrwSettings.vim") |call netrw#ErrorMsg(1,"unable to remove ".dir."/autoload/netrwSettings.vim",55) |endif |
| 1299 | if s:NetrwDelete(dir."/autoload/netrw.vim") |call netrw#ErrorMsg(1,"unable to remove ".dir."/autoload/netrw.vim",55) |endif |
| 1300 | if s:NetrwDelete(dir."/syntax/netrw.vim") |call netrw#ErrorMsg(1,"unable to remove ".dir."/syntax/netrw.vim",55) |endif |
| 1301 | if s:NetrwDelete(dir."/syntax/netrwlist.vim") |call netrw#ErrorMsg(1,"unable to remove ".dir."/syntax/netrwlist.vim",55) |endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1302 | let diddir= dir |
| 1303 | let diddel= diddel + 1 |
| 1304 | if !a:sys|break|endif |
| 1305 | endif |
| 1306 | endfor |
| 1307 | endif |
| 1308 | |
| 1309 | echohl WarningMsg |
| 1310 | if diddel == 0 |
| 1311 | echomsg "netrw is either not installed or not removable" |
| 1312 | elseif diddel == 1 |
| 1313 | echomsg "removed one copy of netrw from <".diddir.">" |
| 1314 | else |
| 1315 | echomsg "removed ".diddel." copies of netrw" |
| 1316 | endif |
| 1317 | echohl None |
| 1318 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1319 | " call Dret("netrw#Clean") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1320 | endfun |
| 1321 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 1322 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1323 | " netrw#MakeTgt: make a target out of the directory name provided {{{2 |
| 1324 | fun! netrw#MakeTgt(dname) |
| 1325 | " call Dfunc("netrw#MakeTgt(dname<".a:dname.">)") |
| 1326 | " simplify the target (eg. /abc/def/../ghi -> /abc/ghi) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1327 | let svpos = winsaveview() |
| 1328 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1329 | let s:netrwmftgt_islocal= (a:dname !~ '^\a\{3,}://') |
| 1330 | " call Decho("s:netrwmftgt_islocal=".s:netrwmftgt_islocal,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1331 | if s:netrwmftgt_islocal |
| 1332 | let netrwmftgt= simplify(a:dname) |
| 1333 | else |
| 1334 | let netrwmftgt= a:dname |
| 1335 | endif |
| 1336 | if exists("s:netrwmftgt") && netrwmftgt == s:netrwmftgt |
| 1337 | " re-selected target, so just clear it |
| 1338 | unlet s:netrwmftgt s:netrwmftgt_islocal |
| 1339 | else |
| 1340 | let s:netrwmftgt= netrwmftgt |
| 1341 | endif |
| 1342 | if g:netrw_fastbrowse <= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1343 | call s:NetrwRefresh((b:netrw_curdir !~ '\a\{3,}://'),b:netrw_curdir) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1344 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1345 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>"))" |
| 1346 | call winrestview(svpos) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1347 | " call Dret("netrw#MakeTgt") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 1348 | endfun |
| 1349 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1350 | " --------------------------------------------------------------------- |
| 1351 | " netrw#Obtain: {{{2 |
| 1352 | " netrw#Obtain(islocal,fname[,tgtdirectory]) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1353 | " islocal=0 obtain from remote source |
| 1354 | " =1 obtain from local source |
| 1355 | " fname : a filename or a list of filenames |
| 1356 | " tgtdir : optional place where files are to go (not present, uses getcwd()) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1357 | fun! netrw#Obtain(islocal,fname,...) |
| 1358 | " call Dfunc("netrw#Obtain(islocal=".a:islocal." fname<".((type(a:fname) == 1)? a:fname : string(a:fname)).">) a:0=".a:0) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1359 | " NetrwStatusLine support - for obtaining support |
| 1360 | |
| 1361 | if type(a:fname) == 1 |
| 1362 | let fnamelist= [ a:fname ] |
| 1363 | elseif type(a:fname) == 3 |
| 1364 | let fnamelist= a:fname |
| 1365 | else |
| 1366 | call netrw#ErrorMsg(s:ERROR,"attempting to use NetrwObtain on something not a filename or a list",62) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1367 | " call Dret("netrw#Obtain") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1368 | return |
| 1369 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1370 | " call Decho("fnamelist<".string(fnamelist).">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1371 | if a:0 > 0 |
| 1372 | let tgtdir= a:1 |
| 1373 | else |
| 1374 | let tgtdir= getcwd() |
| 1375 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1376 | " call Decho("tgtdir<".tgtdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1377 | |
| 1378 | if exists("b:netrw_islocal") && b:netrw_islocal |
| 1379 | " obtain a file from local b:netrw_curdir to (local) tgtdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1380 | " call Decho("obtain a file from local ".b:netrw_curdir." to ".tgtdir,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1381 | if exists("b:netrw_curdir") && getcwd() != b:netrw_curdir |
| 1382 | let topath= s:ComposePath(tgtdir,"") |
| 1383 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
| 1384 | " transfer files one at time |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1385 | " call Decho("transfer files one at a time",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1386 | for fname in fnamelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1387 | " call Decho("system(".g:netrw_localcopycmd." ".s:ShellEscape(fname)." ".s:ShellEscape(topath).")",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1388 | call system(g:netrw_localcopycmd.g:netrw_localcopycmdopt." ".s:ShellEscape(fname)." ".s:ShellEscape(topath)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1389 | if v:shell_error != 0 |
| 1390 | call netrw#ErrorMsg(s:WARNING,"consider setting g:netrw_localcopycmd<".g:netrw_localcopycmd."> to something that works",80) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1391 | " call Dret("s:NetrwObtain 0 : failed: ".g:netrw_localcopycmd." ".s:ShellEscape(fname)." ".s:ShellEscape(topath)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1392 | return |
| 1393 | endif |
| 1394 | endfor |
| 1395 | else |
| 1396 | " transfer files with one command |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1397 | " call Decho("transfer files with one command",'~'.expand("<slnum>")) |
| 1398 | let filelist= join(map(deepcopy(fnamelist),"s:ShellEscape(v:val)")) |
| 1399 | " call Decho("system(".g:netrw_localcopycmd." ".filelist." ".s:ShellEscape(topath).")",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1400 | call system(g:netrw_localcopycmd.g:netrw_localcopycmdopt." ".filelist." ".s:ShellEscape(topath)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1401 | if v:shell_error != 0 |
| 1402 | call netrw#ErrorMsg(s:WARNING,"consider setting g:netrw_localcopycmd<".g:netrw_localcopycmd."> to something that works",80) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1403 | " call Dret("s:NetrwObtain 0 : failed: ".g:netrw_localcopycmd." ".filelist." ".s:ShellEscape(topath)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1404 | return |
| 1405 | endif |
| 1406 | endif |
| 1407 | elseif !exists("b:netrw_curdir") |
| 1408 | call netrw#ErrorMsg(s:ERROR,"local browsing directory doesn't exist!",36) |
| 1409 | else |
| 1410 | call netrw#ErrorMsg(s:WARNING,"local browsing directory and current directory are identical",37) |
| 1411 | endif |
| 1412 | |
| 1413 | else |
| 1414 | " obtain files from remote b:netrw_curdir to local tgtdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1415 | " call Decho("obtain a file from remote ".b:netrw_curdir." to ".tgtdir,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1416 | if type(a:fname) == 1 |
| 1417 | call s:SetupNetrwStatusLine('%f %h%m%r%=%9*Obtaining '.a:fname) |
| 1418 | endif |
| 1419 | call s:NetrwMethod(b:netrw_curdir) |
| 1420 | |
| 1421 | if b:netrw_method == 4 |
| 1422 | " obtain file using scp |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1423 | " call Decho("obtain via scp (method#4)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1424 | if exists("g:netrw_port") && g:netrw_port != "" |
| 1425 | let useport= " ".g:netrw_scpport." ".g:netrw_port |
| 1426 | else |
| 1427 | let useport= "" |
| 1428 | endif |
| 1429 | if b:netrw_fname =~ '/' |
| 1430 | let path= substitute(b:netrw_fname,'^\(.*/\).\{-}$','\1','') |
| 1431 | else |
| 1432 | let path= "" |
| 1433 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1434 | let filelist= join(map(deepcopy(fnamelist),'escape(s:ShellEscape(g:netrw_machine.":".path.v:val,1)," ")')) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1435 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_scp_cmd.s:ShellEscape(useport,1)." ".filelist." ".s:ShellEscape(tgtdir,1)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1436 | |
| 1437 | elseif b:netrw_method == 2 |
| 1438 | " obtain file using ftp + .netrc |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1439 | " call Decho("obtain via ftp+.netrc (method #2)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1440 | call s:SaveBufVars()|sil NetrwKeepj new|call s:RestoreBufVars() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1441 | let tmpbufnr= bufnr("%") |
| 1442 | setl ff=unix |
| 1443 | if exists("g:netrw_ftpmode") && g:netrw_ftpmode != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1444 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1445 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1446 | endif |
| 1447 | |
| 1448 | if exists("b:netrw_fname") && b:netrw_fname != "" |
| 1449 | call setline(line("$")+1,'cd "'.b:netrw_fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1450 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1451 | endif |
| 1452 | |
| 1453 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1454 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1455 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1456 | endif |
| 1457 | for fname in fnamelist |
| 1458 | call setline(line("$")+1,'get "'.fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1459 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1460 | endfor |
| 1461 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1462 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1463 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1464 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1465 | endif |
| 1466 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
| 1467 | if getline(1) !~ "^$" && !exists("g:netrw_quiet") && getline(1) !~ '^Trying ' |
| 1468 | let debugkeep= &debug |
| 1469 | setl debug=msg |
| 1470 | call netrw#ErrorMsg(s:ERROR,getline(1),4) |
| 1471 | let &debug= debugkeep |
| 1472 | endif |
| 1473 | |
| 1474 | elseif b:netrw_method == 3 |
| 1475 | " obtain with ftp + machine, id, passwd, and fname (ie. no .netrc) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1476 | " call Decho("obtain via ftp+mipf (method #3)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1477 | call s:SaveBufVars()|sil NetrwKeepj new|call s:RestoreBufVars() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1478 | let tmpbufnr= bufnr("%") |
| 1479 | setl ff=unix |
| 1480 | |
| 1481 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1482 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1483 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1484 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1485 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1486 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1487 | endif |
| 1488 | |
| 1489 | if exists("g:netrw_uid") && g:netrw_uid != "" |
| 1490 | if exists("g:netrw_ftp") && g:netrw_ftp == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1491 | NetrwKeepj put =g:netrw_uid |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1492 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1493 | if exists("s:netrw_passwd") && s:netrw_passwd != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1494 | NetrwKeepj put ='\"'.s:netrw_passwd.'\"' |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1495 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1496 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1497 | elseif exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1498 | NetrwKeepj put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1499 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1500 | endif |
| 1501 | endif |
| 1502 | |
| 1503 | if exists("g:netrw_ftpmode") && g:netrw_ftpmode != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1504 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1505 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1506 | endif |
| 1507 | |
| 1508 | if exists("b:netrw_fname") && b:netrw_fname != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1509 | NetrwKeepj call setline(line("$")+1,'cd "'.b:netrw_fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1510 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1511 | endif |
| 1512 | |
| 1513 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1514 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1515 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1516 | endif |
| 1517 | |
| 1518 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1519 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1520 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1521 | endif |
| 1522 | for fname in fnamelist |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1523 | NetrwKeepj call setline(line("$")+1,'get "'.fname.'"') |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1524 | endfor |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1525 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1526 | |
| 1527 | " perform ftp: |
| 1528 | " -i : turns off interactive prompting from ftp |
| 1529 | " -n unix : DON'T use <.netrc>, even though it exists |
| 1530 | " -n win32: quit being obnoxious about password |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1531 | NetrwKeepj norm! 1Gdd |
| 1532 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." ".g:netrw_ftp_options) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1533 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
| 1534 | if getline(1) !~ "^$" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1535 | " call Decho("error<".getline(1).">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1536 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1537 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,getline(1),5) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1538 | endif |
| 1539 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1540 | |
| 1541 | elseif b:netrw_method == 9 |
| 1542 | " obtain file using sftp |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1543 | " call Decho("obtain via sftp (method #9)",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1544 | if a:fname =~ '/' |
| 1545 | let localfile= substitute(a:fname,'^.*/','','') |
| 1546 | else |
| 1547 | let localfile= a:fname |
| 1548 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1549 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_sftp_cmd." ".s:ShellEscape(g:netrw_machine.":".b:netrw_fname,1).s:ShellEscape(localfile)." ".s:ShellEscape(tgtdir)) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1550 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1551 | elseif !exists("b:netrw_method") || b:netrw_method < 0 |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1552 | " probably a badly formed url; protocol not recognized |
| 1553 | " call Dret("netrw#Obtain : unsupported method") |
| 1554 | return |
| 1555 | |
| 1556 | else |
| 1557 | " protocol recognized but not supported for Obtain (yet?) |
| 1558 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1559 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"current protocol not supported for obtaining file",97) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1560 | endif |
| 1561 | " call Dret("netrw#Obtain : current protocol not supported for obtaining file") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1562 | return |
| 1563 | endif |
| 1564 | |
| 1565 | " restore status line |
| 1566 | if type(a:fname) == 1 && exists("s:netrw_users_stl") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1567 | NetrwKeepj call s:SetupNetrwStatusLine(s:netrw_users_stl) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1568 | endif |
| 1569 | |
| 1570 | endif |
| 1571 | |
| 1572 | " cleanup |
| 1573 | if exists("tmpbufnr") |
| 1574 | if bufnr("%") != tmpbufnr |
| 1575 | exe tmpbufnr."bw!" |
| 1576 | else |
| 1577 | q! |
| 1578 | endif |
| 1579 | endif |
| 1580 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1581 | " call Dret("netrw#Obtain") |
| 1582 | endfun |
| 1583 | |
| 1584 | " --------------------------------------------------------------------- |
| 1585 | " netrw#Nread: save position, call netrw#NetRead(), and restore position {{{2 |
| 1586 | fun! netrw#Nread(mode,fname) |
| 1587 | " call Dfunc("netrw#Nread(mode=".a:mode." fname<".a:fname.">)") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1588 | let svpos= winsaveview() |
| 1589 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1590 | call netrw#NetRead(a:mode,a:fname) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1591 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 1592 | call winrestview(svpos) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1593 | |
| 1594 | if exists("w:netrw_liststyle") && w:netrw_liststyle != s:TREELIST |
| 1595 | if exists("w:netrw_bannercnt") |
| 1596 | " start with cursor just after the banner |
| 1597 | exe w:netrw_bannercnt |
| 1598 | endif |
| 1599 | endif |
| 1600 | " call Dret("netrw#Nread") |
| 1601 | endfun |
| 1602 | |
| 1603 | " ------------------------------------------------------------------------ |
| 1604 | " s:NetrwOptionRestore: restore options (based on prior s:NetrwOptionSave) {{{2 |
| 1605 | fun! s:NetrwOptionRestore(vt) |
| 1606 | " call Dfunc("s:NetrwOptionRestore(vt<".a:vt.">) win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> winnr($)=".winnr("$")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1607 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo." a:vt=".a:vt,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1608 | if !exists("{a:vt}netrw_optionsave") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1609 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo." a:vt=".a:vt,'~'.expand("<slnum>")) |
| 1610 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1611 | " call Dret("s:NetrwOptionRestore : ".a:vt."netrw_optionsave doesn't exist") |
| 1612 | return |
| 1613 | endif |
| 1614 | unlet {a:vt}netrw_optionsave |
| 1615 | |
| 1616 | if exists("+acd") |
| 1617 | if exists("{a:vt}netrw_acdkeep") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1618 | " call Decho("g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1619 | let curdir = getcwd() |
| 1620 | let &l:acd = {a:vt}netrw_acdkeep |
| 1621 | unlet {a:vt}netrw_acdkeep |
| 1622 | if &l:acd |
| 1623 | call s:NetrwLcd(curdir) |
| 1624 | endif |
| 1625 | endif |
| 1626 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1627 | call s:NetrwRestoreSetting(a:vt."netrw_aikeep","&l:ai") |
| 1628 | call s:NetrwRestoreSetting(a:vt."netrw_awkeep","&l:aw") |
| 1629 | call s:NetrwRestoreSetting(a:vt."netrw_blkeep","&l:bl") |
| 1630 | call s:NetrwRestoreSetting(a:vt."netrw_btkeep","&l:bt") |
| 1631 | call s:NetrwRestoreSetting(a:vt."netrw_bombkeep","&l:bomb") |
| 1632 | call s:NetrwRestoreSetting(a:vt."netrw_cedit","&cedit") |
| 1633 | call s:NetrwRestoreSetting(a:vt."netrw_cikeep","&l:ci") |
| 1634 | call s:NetrwRestoreSetting(a:vt."netrw_cinkeep","&l:cin") |
| 1635 | call s:NetrwRestoreSetting(a:vt."netrw_cinokeep","&l:cino") |
| 1636 | call s:NetrwRestoreSetting(a:vt."netrw_comkeep","&l:com") |
| 1637 | call s:NetrwRestoreSetting(a:vt."netrw_cpokeep","&l:cpo") |
| 1638 | call s:NetrwRestoreSetting(a:vt."netrw_diffkeep","&l:diff") |
| 1639 | call s:NetrwRestoreSetting(a:vt."netrw_fenkeep","&l:fen") |
| 1640 | if exists("g:netrw_ffkeep") && g:netrw_ffkeep |
| 1641 | call s:NetrwRestoreSetting(a:vt."netrw_ffkeep")","&l:ff") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1642 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1643 | call s:NetrwRestoreSetting(a:vt."netrw_fokeep","&l:fo") |
| 1644 | call s:NetrwRestoreSetting(a:vt."netrw_gdkeep","&l:gd") |
| 1645 | call s:NetrwRestoreSetting(a:vt."netrw_hidkeep","&l:hidden") |
| 1646 | call s:NetrwRestoreSetting(a:vt."netrw_imkeep","&l:im") |
| 1647 | call s:NetrwRestoreSetting(a:vt."netrw_iskkeep","&l:isk") |
| 1648 | call s:NetrwRestoreSetting(a:vt."netrw_lskeep","&l:ls") |
| 1649 | call s:NetrwRestoreSetting(a:vt."netrw_makeep","&l:ma") |
| 1650 | call s:NetrwRestoreSetting(a:vt."netrw_magickeep","&l:magic") |
| 1651 | call s:NetrwRestoreSetting(a:vt."netrw_modkeep","&l:mod") |
| 1652 | call s:NetrwRestoreSetting(a:vt."netrw_nukeep","&l:nu") |
| 1653 | call s:NetrwRestoreSetting(a:vt."netrw_rnukeep","&l:rnu") |
| 1654 | call s:NetrwRestoreSetting(a:vt."netrw_repkeep","&l:report") |
| 1655 | call s:NetrwRestoreSetting(a:vt."netrw_rokeep","&l:ro") |
| 1656 | call s:NetrwRestoreSetting(a:vt."netrw_selkeep","&l:sel") |
| 1657 | call s:NetrwRestoreSetting(a:vt."netrw_spellkeep","&l:spell") |
| 1658 | call s:NetrwRestoreSetting(a:vt."netrw_twkeep","&l:tw") |
| 1659 | call s:NetrwRestoreSetting(a:vt."netrw_wigkeep","&l:wig") |
| 1660 | call s:NetrwRestoreSetting(a:vt."netrw_wrapkeep","&l:wrap") |
| 1661 | call s:NetrwRestoreSetting(a:vt."netrw_writekeep","&l:write") |
| 1662 | call s:NetrwRestoreSetting("s:yykeep","@@") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1663 | " Problem: start with liststyle=0; press <i> : result, following line resets l:ts. |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1664 | call s:NetrwRestoreSetting(a:vt."netrw_tskeep","&l:ts") |
| 1665 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1666 | if exists("{a:vt}netrw_swfkeep") |
| 1667 | if &directory == "" |
| 1668 | " user hasn't specified a swapfile directory; |
| 1669 | " netrw will temporarily set the swapfile directory |
| 1670 | " to the current directory as returned by getcwd(). |
| 1671 | let &l:directory= getcwd() |
| 1672 | sil! let &l:swf = {a:vt}netrw_swfkeep |
| 1673 | setl directory= |
| 1674 | unlet {a:vt}netrw_swfkeep |
| 1675 | elseif &l:swf != {a:vt}netrw_swfkeep |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1676 | if !g:netrw_use_noswf |
| 1677 | " following line causes a Press ENTER in windows -- can't seem to work around it!!! |
| 1678 | sil! let &l:swf= {a:vt}netrw_swfkeep |
| 1679 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1680 | unlet {a:vt}netrw_swfkeep |
| 1681 | endif |
| 1682 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1683 | if exists("{a:vt}netrw_dirkeep") && isdirectory(s:NetrwFile({a:vt}netrw_dirkeep)) && g:netrw_keepdir |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1684 | let dirkeep = substitute({a:vt}netrw_dirkeep,'\\','/','g') |
| 1685 | if exists("{a:vt}netrw_dirkeep") |
| 1686 | call s:NetrwLcd(dirkeep) |
| 1687 | unlet {a:vt}netrw_dirkeep |
| 1688 | endif |
| 1689 | endif |
| 1690 | if has("clipboard") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1691 | call s:NetrwRestoreSetting(a:vt."netrw_starkeep","@*") |
| 1692 | call s:NetrwRestoreSetting(a:vt."netrw_pluskeep","@+") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1693 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1694 | call s:NetrwRestoreSetting(a:vt."netrw_slashkeep","@/") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1695 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1696 | " call Decho("g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd,'~'.expand("<slnum>")) |
| 1697 | " call Decho("fo=".&fo.(exists("+acd")? " acd=".&acd : " acd doesn't exist"),'~'.expand("<slnum>")) |
| 1698 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
| 1699 | " call Decho("diff=".&l:diff." win#".winnr()." w:netrw_diffkeep=".(exists("w:netrw_diffkeep")? w:netrw_diffkeep : "doesn't exist"),'~'.expand("<slnum>")) |
| 1700 | " call Decho("ts=".&l:ts,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1701 | " Moved the filetype detect here from NetrwGetFile() because remote files |
| 1702 | " were having their filetype detect-generated settings overwritten by |
| 1703 | " NetrwOptionRestore. |
| 1704 | if &ft != "netrw" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1705 | " call Decho("filetype detect (ft=".&ft.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1706 | filetype detect |
| 1707 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1708 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo." a:vt=".a:vt,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1709 | " call Dret("s:NetrwOptionRestore : tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> modified=".&modified." modifiable=".&modifiable." readonly=".&readonly) |
| 1710 | endfun |
| 1711 | |
| 1712 | " --------------------------------------------------------------------- |
| 1713 | " s:NetrwOptionSave: save options prior to setting to "netrw-buffer-standard" form {{{2 |
| 1714 | " Options get restored by s:NetrwOptionRestore() |
| 1715 | " 06/08/07 : removed call to NetrwSafeOptions(), either placed |
| 1716 | " immediately after NetrwOptionSave() calls in NetRead |
| 1717 | " and NetWrite, or after the s:NetrwEnew() call in |
| 1718 | " NetrwBrowse. |
| 1719 | " vt: normally its "w:" or "s:" (a variable type) |
| 1720 | fun! s:NetrwOptionSave(vt) |
| 1721 | " call Dfunc("s:NetrwOptionSave(vt<".a:vt.">) win#".winnr()." buf#".bufnr("%")."<".bufname(bufnr("%")).">"." winnr($)=".winnr("$")." mod=".&mod." ma=".&ma) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1722 | " call Decho(a:vt."netrw_optionsave".(exists("{a:vt}netrw_optionsave")? ("=".{a:vt}netrw_optionsave) : " doesn't exist"),'~'.expand("<slnum>")) |
| 1723 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo." a:vt=".a:vt,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1724 | |
| 1725 | if !exists("{a:vt}netrw_optionsave") |
| 1726 | let {a:vt}netrw_optionsave= 1 |
| 1727 | else |
| 1728 | " call Dret("s:NetrwOptionSave : options already saved") |
| 1729 | return |
| 1730 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1731 | " call Decho("prior to save: fo=".&fo.(exists("+acd")? " acd=".&acd : " acd doesn't exist")." diff=".&l:diff,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1732 | |
| 1733 | " Save current settings and current directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1734 | " call Decho("saving current settings and current directory",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1735 | let s:yykeep = @@ |
| 1736 | if exists("&l:acd")|let {a:vt}netrw_acdkeep = &l:acd|endif |
| 1737 | let {a:vt}netrw_aikeep = &l:ai |
| 1738 | let {a:vt}netrw_awkeep = &l:aw |
| 1739 | let {a:vt}netrw_bhkeep = &l:bh |
| 1740 | let {a:vt}netrw_blkeep = &l:bl |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1741 | let {a:vt}netrw_btkeep = &l:bt |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1742 | let {a:vt}netrw_bombkeep = &l:bomb |
| 1743 | let {a:vt}netrw_cedit = &cedit |
| 1744 | let {a:vt}netrw_cikeep = &l:ci |
| 1745 | let {a:vt}netrw_cinkeep = &l:cin |
| 1746 | let {a:vt}netrw_cinokeep = &l:cino |
| 1747 | let {a:vt}netrw_comkeep = &l:com |
| 1748 | let {a:vt}netrw_cpokeep = &l:cpo |
| 1749 | let {a:vt}netrw_diffkeep = &l:diff |
| 1750 | let {a:vt}netrw_fenkeep = &l:fen |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1751 | if !exists("g:netrw_ffkeep") || g:netrw_ffkeep |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1752 | let {a:vt}netrw_ffkeep = &l:ff |
| 1753 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1754 | let {a:vt}netrw_fokeep = &l:fo " formatoptions |
| 1755 | let {a:vt}netrw_gdkeep = &l:gd " gdefault |
| 1756 | let {a:vt}netrw_hidkeep = &l:hidden |
| 1757 | let {a:vt}netrw_imkeep = &l:im |
| 1758 | let {a:vt}netrw_iskkeep = &l:isk |
| 1759 | let {a:vt}netrw_lskeep = &l:ls |
| 1760 | let {a:vt}netrw_makeep = &l:ma |
| 1761 | let {a:vt}netrw_magickeep = &l:magic |
| 1762 | let {a:vt}netrw_modkeep = &l:mod |
| 1763 | let {a:vt}netrw_nukeep = &l:nu |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 1764 | let {a:vt}netrw_rnukeep = &l:rnu |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1765 | let {a:vt}netrw_repkeep = &l:report |
| 1766 | let {a:vt}netrw_rokeep = &l:ro |
| 1767 | let {a:vt}netrw_selkeep = &l:sel |
| 1768 | let {a:vt}netrw_spellkeep = &l:spell |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 1769 | if !g:netrw_use_noswf |
| 1770 | let {a:vt}netrw_swfkeep = &l:swf |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1771 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1772 | let {a:vt}netrw_tskeep = &l:ts |
| 1773 | let {a:vt}netrw_twkeep = &l:tw " textwidth |
| 1774 | let {a:vt}netrw_wigkeep = &l:wig " wildignore |
| 1775 | let {a:vt}netrw_wrapkeep = &l:wrap |
| 1776 | let {a:vt}netrw_writekeep = &l:write |
| 1777 | |
| 1778 | " save a few selected netrw-related variables |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1779 | " call Decho("saving a few selected netrw-related variables",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1780 | if g:netrw_keepdir |
| 1781 | let {a:vt}netrw_dirkeep = getcwd() |
| 1782 | endif |
| 1783 | if has("clipboard") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1784 | sil! let {a:vt}netrw_starkeep = @* |
| 1785 | sil! let {a:vt}netrw_pluskeep = @+ |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1786 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1787 | sil! let {a:vt}netrw_slashkeep= @/ |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1788 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1789 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo." a:vt=".a:vt,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1790 | " call Dret("s:NetrwOptionSave : tab#".tabpagenr()." win#".winnr()) |
| 1791 | endfun |
| 1792 | |
| 1793 | " ------------------------------------------------------------------------ |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1794 | " s:NetrwRestoreSetting: restores specified setting using associated keepvar, {{{2 |
| 1795 | " but only if the setting value differs from the associated keepvar. |
| 1796 | " Doing this means that netrw will not come up as having changed a |
| 1797 | " setting last when it really didn't actually change it. |
| 1798 | " Used by s:NetrwOptionRestore() to restore each netrw-senstive setting |
| 1799 | " and by s:NetrwSafeOptions() |
| 1800 | fun! s:NetrwRestoreSetting(keepvar,setting) |
| 1801 | " call Dfunc("s:NetrwRestoreSetting(keepvar<".a:keepvar."> setting<".a:setting.">)") |
| 1802 | |
| 1803 | if a:keepvar =~ '^&' |
| 1804 | exe "let keepvarval= ".a:keepvar |
| 1805 | if keepvarval != a:setting |
| 1806 | if type(a:setting) == 0 |
| 1807 | exe "let ".a:keepvar."=".a:setting |
| 1808 | elseif type(a:setting) == 1 |
| 1809 | exe "let ".a:keepvar."= '".a:setting."'" |
| 1810 | else |
| 1811 | call netrw#ErrorMsg(s:ERROR,"(s:NetrwRestoreSetting) doesn't know how to restore ".a:keepvar." with a setting of type#".type(a:setting),105) |
| 1812 | endif |
| 1813 | endif |
| 1814 | |
| 1815 | elseif exists(a:keepvar) |
| 1816 | exe "let keepvarval= '".a:keepvar."'" |
| 1817 | if keepvarval != a:setting |
| 1818 | if type(a:setting) == 0 |
| 1819 | exe "let ".a:keepvar."= ".a:setting |
| 1820 | elseif type(a:setting) == 1 |
| 1821 | exe "let ".a:keepvar."= '".a:setting."'" |
| 1822 | else |
| 1823 | call netrw#ErrorMsg(s:ERROR,"(s:NetrwRestoreSetting) doesn't know how to restore ".a:keepvar." with a setting of type#".type(a:setting),105) |
| 1824 | endif |
| 1825 | endif |
| 1826 | exe "unlet ".a:keepvar |
| 1827 | endif |
| 1828 | " call Dret("s:NetrwRestoreSetting") |
| 1829 | endfun |
| 1830 | |
| 1831 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1832 | " s:NetrwSafeOptions: sets options to help netrw do its job {{{2 |
| 1833 | " Use s:NetrwSaveOptions() to save user settings |
| 1834 | " Use s:NetrwOptionRestore() to restore user settings |
| 1835 | fun! s:NetrwSafeOptions() |
| 1836 | " call Dfunc("s:NetrwSafeOptions() win#".winnr()." buf#".bufnr("%")."<".bufname(bufnr("%"))."> winnr($)=".winnr("$")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1837 | " call Decho("win#".winnr()."'s ft=".&ft,'~'.expand("<slnum>")) |
| 1838 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1839 | if exists("+acd") | call s:NetrwRestoreSetting("&l:acd",0)|endif |
| 1840 | call s:NetrwRestoreSetting("&l:ai",0) |
| 1841 | call s:NetrwRestoreSetting("&l:aw",0) |
| 1842 | call s:NetrwRestoreSetting("&l:bl",0) |
| 1843 | call s:NetrwRestoreSetting("&l:bomb",0) |
| 1844 | call s:NetrwRestoreSetting("&l:bt","nofile") |
| 1845 | call s:NetrwRestoreSetting("&l:ci",0) |
| 1846 | call s:NetrwRestoreSetting("&l:cin",0) |
| 1847 | call s:NetrwRestoreSetting("&l:bh","hide") |
| 1848 | call s:NetrwRestoreSetting("&l:cino","") |
| 1849 | call s:NetrwRestoreSetting("&l:com","") |
| 1850 | if &cpo =~ 'a' | call s:NetrwRestoreSetting("&cpo",substitute(&cpo,'a','','g')) | endif |
| 1851 | if &cpo =~ 'A' | call s:NetrwRestoreSetting("&cpo",substitute(&cpo,'A','','g')) | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1852 | setl fo=nroql2 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1853 | call s:NetrwRestoreSetting("&l:hid",0) |
| 1854 | call s:NetrwRestoreSetting("&l:im",0) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1855 | setl isk+=@ isk+=* isk+=/ |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1856 | call s:NetrwRestoreSetting("&l:magic",1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1857 | if g:netrw_use_noswf |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1858 | call s:NetrwRestoreSetting("swf",0) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1859 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1860 | call s:NetrwRestoreSetting("&l:report",10000) |
| 1861 | call s:NetrwRestoreSetting("&l:sel","inclusive") |
| 1862 | call s:NetrwRestoreSetting("&l:spell",0) |
| 1863 | call s:NetrwRestoreSetting("&l:tw",0) |
| 1864 | call s:NetrwRestoreSetting("&l:wig","") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1865 | setl cedit& |
| 1866 | call s:NetrwCursor() |
| 1867 | |
| 1868 | " allow the user to override safe options |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1869 | " call Decho("ft<".&ft."> ei=".&ei,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1870 | if &ft == "netrw" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1871 | " call Decho("do any netrw FileType autocmds (doau FileType netrw)",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1872 | keepalt NetrwKeepj doau FileType netrw |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1873 | endif |
| 1874 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1875 | " call Decho("fo=".&fo.(exists("+acd")? " acd=".&acd : " acd doesn't exist")." bh=".&l:bh." bt<".&bt.">",'~'.expand("<slnum>")) |
| 1876 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1877 | " call Dret("s:NetrwSafeOptions") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 1878 | endfun |
| 1879 | |
| 1880 | " --------------------------------------------------------------------- |
| 1881 | " NetrwStatusLine: {{{2 |
| 1882 | fun! NetrwStatusLine() |
| 1883 | |
| 1884 | " vvv NetrwStatusLine() debugging vvv |
| 1885 | " let g:stlmsg="" |
| 1886 | " if !exists("w:netrw_explore_bufnr") |
| 1887 | " let g:stlmsg="!X<explore_bufnr>" |
| 1888 | " elseif w:netrw_explore_bufnr != bufnr("%") |
| 1889 | " let g:stlmsg="explore_bufnr!=".bufnr("%") |
| 1890 | " endif |
| 1891 | " if !exists("w:netrw_explore_line") |
| 1892 | " let g:stlmsg=" !X<explore_line>" |
| 1893 | " elseif w:netrw_explore_line != line(".") |
| 1894 | " let g:stlmsg=" explore_line!={line(.)<".line(".").">" |
| 1895 | " endif |
| 1896 | " if !exists("w:netrw_explore_list") |
| 1897 | " let g:stlmsg=" !X<explore_list>" |
| 1898 | " endif |
| 1899 | " ^^^ NetrwStatusLine() debugging ^^^ |
| 1900 | |
| 1901 | 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") |
| 1902 | " restore user's status line |
| 1903 | let &stl = s:netrw_users_stl |
| 1904 | let &laststatus = s:netrw_users_ls |
| 1905 | if exists("w:netrw_explore_bufnr")|unlet w:netrw_explore_bufnr|endif |
| 1906 | if exists("w:netrw_explore_line") |unlet w:netrw_explore_line |endif |
| 1907 | return "" |
| 1908 | else |
| 1909 | return "Match ".w:netrw_explore_mtchcnt." of ".w:netrw_explore_listlen |
| 1910 | endif |
| 1911 | endfun |
| 1912 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 1913 | " =============================== |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 1914 | " Netrw Transfer Functions: {{{1 |
| 1915 | " =============================== |
| 1916 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1917 | " ------------------------------------------------------------------------ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1918 | " netrw#NetRead: responsible for reading a file over the net {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1919 | " mode: =0 read remote file and insert before current line |
| 1920 | " =1 read remote file and insert after current line |
| 1921 | " =2 replace with remote file |
| 1922 | " =3 obtain file, but leave in temporary format |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1923 | fun! netrw#NetRead(mode,...) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 1924 | " call Dfunc("netrw#NetRead(mode=".a:mode.",...) a:0=".a:0." ".g:loaded_netrw.((a:0 > 0)? " a:1<".a:1.">" : "")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1925 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 1926 | " NetRead: save options {{{3 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 1927 | call s:NetrwOptionSave("w:") |
| 1928 | call s:NetrwSafeOptions() |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 1929 | call s:RestoreCursorline() |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1930 | " NetrwSafeOptions sets a buffer up for a netrw listing, which includes buflisting off. |
| 1931 | " However, this setting is not wanted for a remote editing session. The buffer should be "nofile", still. |
| 1932 | setl bl |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1933 | " call Decho("(netrw#NetRead) buf#".bufnr("%")."<".bufname("%")."> bl=".&bl." bt=".&bt." bh=".&bh,'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1934 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 1935 | " NetRead: interpret mode into a readcmd {{{3 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1936 | if a:mode == 0 " read remote file before current line |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1937 | let readcmd = "0r" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1938 | elseif a:mode == 1 " read file after current line |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1939 | let readcmd = "r" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1940 | elseif a:mode == 2 " replace with remote file |
| 1941 | let readcmd = "%r" |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1942 | elseif a:mode == 3 " skip read of file (leave as temporary) |
| 1943 | let readcmd = "t" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1944 | else |
| 1945 | exe a:mode |
| 1946 | let readcmd = "r" |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1947 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1948 | let ichoice = (a:0 == 0)? 0 : 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1949 | " call Decho("readcmd<".readcmd."> ichoice=".ichoice,'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1950 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 1951 | " NetRead: get temporary filename {{{3 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1952 | let tmpfile= s:GetTempfile("") |
| 1953 | if tmpfile == "" |
| 1954 | " call Dret("netrw#NetRead : unable to get a tempfile!") |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 1955 | return |
| 1956 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1957 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1958 | while ichoice <= a:0 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1959 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1960 | " attempt to repeat with previous host-file-etc |
| 1961 | if exists("b:netrw_lastfile") && a:0 == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1962 | " call Decho("using b:netrw_lastfile<" . b:netrw_lastfile . ">",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1963 | let choice = b:netrw_lastfile |
| 1964 | let ichoice= ichoice + 1 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1965 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1966 | else |
| 1967 | exe "let choice= a:" . ichoice |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1968 | " call Decho("no lastfile: choice<" . choice . ">",'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1969 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1970 | if match(choice,"?") == 0 |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1971 | " give help |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1972 | echomsg 'NetRead Usage:' |
| 1973 | echomsg ':Nread machine:path uses rcp' |
| 1974 | echomsg ':Nread "machine path" uses ftp with <.netrc>' |
| 1975 | echomsg ':Nread "machine id password path" uses ftp' |
| 1976 | echomsg ':Nread dav://machine[:port]/path uses cadaver' |
| 1977 | echomsg ':Nread fetch://machine/path uses fetch' |
| 1978 | echomsg ':Nread ftp://[user@]machine[:port]/path uses ftp autodetects <.netrc>' |
| 1979 | echomsg ':Nread http://[user@]machine/path uses http wget' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 1980 | echomsg ':Nread file:///path uses elinks' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 1981 | echomsg ':Nread https://[user@]machine/path uses http wget' |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1982 | echomsg ':Nread rcp://[user@]machine/path uses rcp' |
| 1983 | echomsg ':Nread rsync://machine[:port]/path uses rsync' |
| 1984 | echomsg ':Nread scp://[user@]machine[[:#]port]/path uses scp' |
| 1985 | echomsg ':Nread sftp://[user@]machine[[:#]port]/path uses sftp' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1986 | sleep 4 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1987 | break |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1988 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1989 | elseif match(choice,'^"') != -1 |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1990 | " Reconstruct Choice if choice starts with '"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 1991 | " call Decho("reconstructing choice",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 1992 | if match(choice,'"$') != -1 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1993 | " case "..." |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 1994 | let choice= strpart(choice,1,strlen(choice)-2) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 1995 | else |
| 1996 | " case "... ... ..." |
| 1997 | let choice = strpart(choice,1,strlen(choice)-1) |
| 1998 | let wholechoice = "" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 1999 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2000 | while match(choice,'"$') == -1 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2001 | let wholechoice = wholechoice . " " . choice |
| 2002 | let ichoice = ichoice + 1 |
| 2003 | if ichoice > a:0 |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2004 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2005 | call netrw#ErrorMsg(s:ERROR,"Unbalanced string in filename '". wholechoice ."'",3) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2006 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2007 | " call Dret("netrw#NetRead :2 getcwd<".getcwd().">") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2008 | return |
| 2009 | endif |
| 2010 | let choice= a:{ichoice} |
| 2011 | endwhile |
| 2012 | let choice= strpart(wholechoice,1,strlen(wholechoice)-1) . " " . strpart(choice,0,strlen(choice)-1) |
| 2013 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2014 | endif |
| 2015 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2016 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2017 | " call Decho("choice<" . choice . ">",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2018 | let ichoice= ichoice + 1 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2019 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2020 | " NetRead: Determine method of read (ftp, rcp, etc) {{{3 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2021 | call s:NetrwMethod(choice) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2022 | if !exists("b:netrw_method") || b:netrw_method < 0 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2023 | " call Dret("netrw#NetRead : unsupported method") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2024 | return |
| 2025 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2026 | let tmpfile= s:GetTempfile(b:netrw_fname) " apply correct suffix |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2027 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2028 | " Check whether or not NetrwBrowse() should be handling this request |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2029 | " call Decho("checking if NetrwBrowse() should handle choice<".choice."> with netrw_list_cmd<".g:netrw_list_cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 2030 | if choice =~ "^.*[\/]$" && b:netrw_method != 5 && choice !~ '^https\=://' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2031 | " call Decho("yes, choice matches '^.*[\/]$'",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2032 | NetrwKeepj call s:NetrwBrowse(0,choice) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2033 | " call Dret("netrw#NetRead :3 getcwd<".getcwd().">") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2034 | return |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2035 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2036 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2037 | " ============ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2038 | " NetRead: Perform Protocol-Based Read {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2039 | " =========================== |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2040 | if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 |
| 2041 | echo "(netrw) Processing your read request..." |
| 2042 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2043 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2044 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2045 | " NetRead: (rcp) NetRead Method #1 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2046 | if b:netrw_method == 1 " read with rcp |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2047 | " call Decho("read via rcp (method #1)",'~'.expand("<slnum>")) |
Bram Moolenaar | d68071d | 2006-05-02 22:08:30 +0000 | [diff] [blame] | 2048 | " ER: nothing done with g:netrw_uid yet? |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2049 | " ER: on Win2K" rcp machine[.user]:file tmpfile |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2050 | " ER: when machine contains '.' adding .user is required (use $USERNAME) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2051 | " ER: the tmpfile is full path: rcp sees C:\... as host C |
| 2052 | if s:netrw_has_nt_rcp == 1 |
| 2053 | if exists("g:netrw_uid") && ( g:netrw_uid != "" ) |
| 2054 | let uid_machine = g:netrw_machine .'.'. g:netrw_uid |
| 2055 | else |
| 2056 | " Any way needed it machine contains a '.' |
| 2057 | let uid_machine = g:netrw_machine .'.'. $USERNAME |
| 2058 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2059 | else |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2060 | if exists("g:netrw_uid") && ( g:netrw_uid != "" ) |
| 2061 | let uid_machine = g:netrw_uid .'@'. g:netrw_machine |
| 2062 | else |
| 2063 | let uid_machine = g:netrw_machine |
| 2064 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2065 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2066 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_rcp_cmd." ".s:netrw_rcpmode." ".s:ShellEscape(uid_machine.":".b:netrw_fname,1)." ".s:ShellEscape(tmpfile,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2067 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2068 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2069 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2070 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2071 | " NetRead: (ftp + <.netrc>) NetRead Method #2 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2072 | elseif b:netrw_method == 2 " read with ftp + <.netrc> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2073 | " call Decho("read via ftp+.netrc (method #2)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8dff818 | 2006-04-06 20:18:50 +0000 | [diff] [blame] | 2074 | let netrw_fname= b:netrw_fname |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2075 | NetrwKeepj call s:SaveBufVars()|new|NetrwKeepj call s:RestoreBufVars() |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2076 | let filtbuf= bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2077 | setl ff=unix |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2078 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2079 | " call Decho("filter input: ".getline(line("$")),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2080 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2081 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2082 | " call Decho("filter input: ".getline(line("$")),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2083 | endif |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2084 | call setline(line("$")+1,'get "'.netrw_fname.'" '.tmpfile) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2085 | " call Decho("filter input: ".getline(line("$")),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2086 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2087 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2088 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2089 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2090 | endif |
| 2091 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
Bram Moolenaar | 83bab71 | 2005-08-01 21:58:57 +0000 | [diff] [blame] | 2092 | if getline(1) !~ "^$" && !exists("g:netrw_quiet") && getline(1) !~ '^Trying ' |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 2093 | let debugkeep = &debug |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2094 | setl debug=msg |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2095 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,getline(1),4) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 2096 | let &debug = debugkeep |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2097 | endif |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 2098 | call s:SaveBufVars() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2099 | keepj bd! |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2100 | if bufname("%") == "" && getline("$") == "" && line('$') == 1 |
| 2101 | " needed when one sources a file in a nolbl setting window via ftp |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 2102 | q! |
| 2103 | endif |
| 2104 | call s:RestoreBufVars() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2105 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2106 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2107 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2108 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2109 | " NetRead: (ftp + machine,id,passwd,filename) NetRead Method #3 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2110 | elseif b:netrw_method == 3 " read with ftp + machine, id, passwd, and fname |
| 2111 | " Construct execution string (four lines) which will be passed through filter |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2112 | " call Decho("read via ftp+mipf (method #3)",'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2113 | let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2114 | NetrwKeepj call s:SaveBufVars()|new|NetrwKeepj call s:RestoreBufVars() |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2115 | let filtbuf= bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2116 | setl ff=unix |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2117 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2118 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2119 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2120 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2121 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2122 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2123 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2124 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 2125 | if exists("g:netrw_uid") && g:netrw_uid != "" |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2126 | if exists("g:netrw_ftp") && g:netrw_ftp == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2127 | NetrwKeepj put =g:netrw_uid |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2128 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2129 | if exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2130 | NetrwKeepj put ='\"'.s:netrw_passwd.'\"' |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2131 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2132 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2133 | elseif exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2134 | NetrwKeepj put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2135 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2136 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2137 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2138 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2139 | if exists("g:netrw_ftpmode") && g:netrw_ftpmode != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2140 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2141 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2142 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2143 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2144 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2145 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2146 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2147 | NetrwKeepj put ='get \"'.netrw_fname.'\" '.tmpfile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2148 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2149 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2150 | " perform ftp: |
| 2151 | " -i : turns off interactive prompting from ftp |
| 2152 | " -n unix : DON'T use <.netrc>, even though it exists |
| 2153 | " -n win32: quit being obnoxious about password |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2154 | NetrwKeepj norm! 1Gdd |
| 2155 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." ".g:netrw_ftp_options) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2156 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
| 2157 | if getline(1) !~ "^$" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2158 | " call Decho("error<".getline(1).">",'~'.expand("<slnum>")) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2159 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2160 | call netrw#ErrorMsg(s:ERROR,getline(1),5) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2161 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2162 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2163 | call s:SaveBufVars()|keepj bd!|call s:RestoreBufVars() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2164 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2165 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2166 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2167 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2168 | " NetRead: (scp) NetRead Method #4 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2169 | elseif b:netrw_method == 4 " read with scp |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2170 | " call Decho("read via scp (method #4)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2171 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 7aa9f6a | 2007-05-10 18:00:30 +0000 | [diff] [blame] | 2172 | let useport= " ".g:netrw_scpport." ".g:netrw_port |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2173 | else |
| 2174 | let useport= "" |
| 2175 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2176 | " 'C' in 'C:\path\to\file' is handled as hostname on windows. |
| 2177 | " This is workaround to avoid mis-handle windows local-path: |
| 2178 | if g:netrw_scp_cmd =~ '^scp' && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 2179 | let tmpfile_get = substitute(tr(tmpfile, '\', '/'), '^\(\a\):[/\\]\(.*\)$', '/\1/\2', '') |
| 2180 | else |
| 2181 | let tmpfile_get = tmpfile |
| 2182 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2183 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_scp_cmd.useport." ".escape(s:ShellEscape(g:netrw_machine.":".b:netrw_fname,1),' ')." ".s:ShellEscape(tmpfile_get,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2184 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2185 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2186 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2187 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2188 | " NetRead: (http) NetRead Method #5 (wget) {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2189 | elseif b:netrw_method == 5 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2190 | " call Decho("read via http (method #5)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2191 | if g:netrw_http_cmd == "" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2192 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2193 | call netrw#ErrorMsg(s:ERROR,"neither the wget nor the fetch command is available",6) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2194 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2195 | " call Dret("netrw#NetRead :4 getcwd<".getcwd().">") |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2196 | return |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2197 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2198 | |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2199 | if match(b:netrw_fname,"#") == -1 || exists("g:netrw_http_xcmd") |
| 2200 | " using g:netrw_http_cmd (usually elinks, links, curl, wget, or fetch) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2201 | " call Decho('using '.g:netrw_http_cmd.' (# not in b:netrw_fname<'.b:netrw_fname.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2202 | if exists("g:netrw_http_xcmd") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2203 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_http_cmd." ".s:ShellEscape(b:netrw_http."://".g:netrw_machine.b:netrw_fname,1)." ".g:netrw_http_xcmd." ".s:ShellEscape(tmpfile,1)) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2204 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2205 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_http_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(b:netrw_http."://".g:netrw_machine.b:netrw_fname,1)) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2206 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2207 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2208 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2209 | else |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2210 | " wget/curl/fetch plus a jump to an in-page marker (ie. http://abc/def.html#aMarker) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2211 | " call Decho("wget/curl plus jump (# in b:netrw_fname<".b:netrw_fname.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 2212 | let netrw_html= substitute(b:netrw_fname,"#.*$","","") |
| 2213 | let netrw_tag = substitute(b:netrw_fname,"^.*#","","") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2214 | " call Decho("netrw_html<".netrw_html.">",'~'.expand("<slnum>")) |
| 2215 | " call Decho("netrw_tag <".netrw_tag.">",'~'.expand("<slnum>")) |
| 2216 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_http_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(b:netrw_http."://".g:netrw_machine.netrw_html,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2217 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2218 | " call Decho('<\s*a\s*name=\s*"'.netrw_tag.'"/','~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2219 | exe 'NetrwKeepj norm! 1G/<\s*a\s*name=\s*"'.netrw_tag.'"/'."\<CR>" |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2220 | endif |
| 2221 | let b:netrw_lastfile = choice |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2222 | " call Decho("setl ro",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 2223 | setl ro nomod |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2224 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2225 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2226 | " NetRead: (dav) NetRead Method #6 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2227 | elseif b:netrw_method == 6 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2228 | " call Decho("read via cadaver (method #6)",'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2229 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2230 | if !executable(g:netrw_dav_cmd) |
| 2231 | call netrw#ErrorMsg(s:ERROR,g:netrw_dav_cmd." is not executable",73) |
| 2232 | " call Dret("netrw#NetRead : ".g:netrw_dav_cmd." not executable") |
| 2233 | return |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2234 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2235 | if g:netrw_dav_cmd =~ "curl" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2236 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_dav_cmd." ".s:ShellEscape("dav://".g:netrw_machine.b:netrw_fname,1)." ".s:ShellEscape(tmpfile,1)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2237 | else |
| 2238 | " Construct execution string (four lines) which will be passed through filter |
| 2239 | let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape) |
| 2240 | new |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2241 | setl ff=unix |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2242 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2243 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2244 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2245 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2246 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2247 | if exists("g:netrw_uid") && exists("s:netrw_passwd") && g:netrw_uid != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2248 | NetrwKeepj put ='user '.g:netrw_uid.' '.s:netrw_passwd |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2249 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2250 | NetrwKeepj put ='get '.netrw_fname.' '.tmpfile |
| 2251 | NetrwKeepj put ='quit' |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2252 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2253 | " perform cadaver operation: |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2254 | NetrwKeepj norm! 1Gdd |
| 2255 | call s:NetrwExe(s:netrw_silentxfer."%!".g:netrw_dav_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2256 | keepj bd! |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2257 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2258 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2259 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2260 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2261 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2262 | " NetRead: (rsync) NetRead Method #7 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2263 | elseif b:netrw_method == 7 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2264 | " call Decho("read via rsync (method #7)",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2265 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_rsync_cmd." ".s:ShellEscape(g:netrw_machine.g:netrw_rsync_sep.b:netrw_fname,1)." ".s:ShellEscape(tmpfile,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2266 | let result = s:NetrwGetFile(readcmd,tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2267 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2268 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2269 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2270 | " NetRead: (fetch) NetRead Method #8 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2271 | " fetch://[user@]host[:http]/path |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2272 | elseif b:netrw_method == 8 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2273 | " call Decho("read via fetch (method #8)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2274 | if g:netrw_fetch_cmd == "" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2275 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2276 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"fetch command not available",7) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2277 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2278 | " call Dret("NetRead") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2279 | return |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2280 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2281 | if exists("g:netrw_option") && g:netrw_option =~ ":https\=" |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2282 | let netrw_option= "http" |
| 2283 | else |
| 2284 | let netrw_option= "ftp" |
| 2285 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2286 | " call Decho("read via fetch for ".netrw_option,'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2287 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2288 | if exists("g:netrw_uid") && g:netrw_uid != "" && exists("s:netrw_passwd") && s:netrw_passwd != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2289 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_fetch_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(netrw_option."://".g:netrw_uid.':'.s:netrw_passwd.'@'.g:netrw_machine."/".b:netrw_fname,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2290 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2291 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_fetch_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(netrw_option."://".g:netrw_machine."/".b:netrw_fname,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2292 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2293 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2294 | let result = s:NetrwGetFile(readcmd,tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2295 | let b:netrw_lastfile = choice |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2296 | " call Decho("setl ro",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 2297 | setl ro nomod |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2298 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2299 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2300 | " NetRead: (sftp) NetRead Method #9 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2301 | elseif b:netrw_method == 9 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2302 | " call Decho("read via sftp (method #9)",'~'.expand("<slnum>")) |
| 2303 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_sftp_cmd." ".s:ShellEscape(g:netrw_machine.":".b:netrw_fname,1)." ".tmpfile) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2304 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2305 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2306 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2307 | "......................................... |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2308 | " NetRead: (file) NetRead Method #10 {{{3 |
| 2309 | elseif b:netrw_method == 10 && exists("g:netrw_file_cmd") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2310 | " " call Decho("read via ".b:netrw_file_cmd." (method #10)",'~'.expand("<slnum>")) |
| 2311 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_file_cmd." ".s:ShellEscape(b:netrw_fname,1)." ".tmpfile) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2312 | let result = s:NetrwGetFile(readcmd, tmpfile, b:netrw_method) |
| 2313 | let b:netrw_lastfile = choice |
| 2314 | |
| 2315 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2316 | " NetRead: Complain {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2317 | else |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2318 | call netrw#ErrorMsg(s:WARNING,"unable to comply with your request<" . choice . ">",8) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2319 | endif |
| 2320 | endwhile |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2321 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2322 | " NetRead: cleanup {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2323 | if exists("b:netrw_method") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2324 | " call Decho("cleanup b:netrw_method and b:netrw_fname",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2325 | unlet b:netrw_method |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2326 | unlet b:netrw_fname |
| 2327 | endif |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2328 | if s:FileReadable(tmpfile) && tmpfile !~ '.tar.bz2$' && tmpfile !~ '.tar.gz$' && tmpfile !~ '.zip' && tmpfile !~ '.tar' && readcmd != 't' && tmpfile !~ '.tar.xz$' && tmpfile !~ '.txz' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2329 | " call Decho("cleanup by deleting tmpfile<".tmpfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2330 | NetrwKeepj call s:NetrwDelete(tmpfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2331 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2332 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | 8299df9 | 2004-07-10 09:47:34 +0000 | [diff] [blame] | 2333 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2334 | " call Dret("netrw#NetRead :5 getcwd<".getcwd().">") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2335 | endfun |
| 2336 | |
| 2337 | " ------------------------------------------------------------------------ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2338 | " netrw#NetWrite: responsible for writing a file over the net {{{2 |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 2339 | fun! netrw#NetWrite(...) range |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2340 | " call Dfunc("netrw#NetWrite(a:0=".a:0.") ".g:loaded_netrw) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2341 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2342 | " NetWrite: option handling {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2343 | let mod= 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2344 | call s:NetrwOptionSave("w:") |
| 2345 | call s:NetrwSafeOptions() |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2346 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2347 | " NetWrite: Get Temporary Filename {{{3 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2348 | let tmpfile= s:GetTempfile("") |
| 2349 | if tmpfile == "" |
| 2350 | " call Dret("netrw#NetWrite : unable to get a tempfile!") |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 2351 | return |
| 2352 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2353 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2354 | if a:0 == 0 |
| 2355 | let ichoice = 0 |
| 2356 | else |
| 2357 | let ichoice = 1 |
| 2358 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2359 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2360 | let curbufname= expand("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2361 | " call Decho("curbufname<".curbufname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2362 | if &binary |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2363 | " For binary writes, always write entire file. |
| 2364 | " (line numbers don't really make sense for that). |
| 2365 | " Also supports the writing of tar and zip files. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2366 | " call Decho("(write entire file) sil exe w! ".fnameescape(v:cmdarg)." ".fnameescape(tmpfile),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2367 | exe "sil NetrwKeepj w! ".fnameescape(v:cmdarg)." ".fnameescape(tmpfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2368 | elseif g:netrw_cygwin |
| 2369 | " write (selected portion of) file to temporary |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2370 | let cygtmpfile= substitute(tmpfile,g:netrw_cygdrive.'/\(.\)','\1:','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2371 | " call Decho("(write selected portion) sil exe ".a:firstline."," . a:lastline . "w! ".fnameescape(v:cmdarg)." ".fnameescape(cygtmpfile),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2372 | exe "sil NetrwKeepj ".a:firstline."," . a:lastline . "w! ".fnameescape(v:cmdarg)." ".fnameescape(cygtmpfile) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2373 | else |
| 2374 | " write (selected portion of) file to temporary |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2375 | " call Decho("(write selected portion) sil exe ".a:firstline."," . a:lastline . "w! ".fnameescape(v:cmdarg)." ".fnameescape(tmpfile),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2376 | exe "sil NetrwKeepj ".a:firstline."," . a:lastline . "w! ".fnameescape(v:cmdarg)." ".fnameescape(tmpfile) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2377 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2378 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2379 | if curbufname == "" |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2380 | " when the file is [No Name], and one attempts to Nwrite it, the buffer takes |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2381 | " on the temporary file's name. Deletion of the temporary file during |
| 2382 | " cleanup then causes an error message. |
| 2383 | 0file! |
| 2384 | endif |
| 2385 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2386 | " NetWrite: while choice loop: {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2387 | while ichoice <= a:0 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2388 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2389 | " Process arguments: {{{4 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2390 | " attempt to repeat with previous host-file-etc |
| 2391 | if exists("b:netrw_lastfile") && a:0 == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2392 | " call Decho("using b:netrw_lastfile<" . b:netrw_lastfile . ">",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2393 | let choice = b:netrw_lastfile |
| 2394 | let ichoice= ichoice + 1 |
| 2395 | else |
| 2396 | exe "let choice= a:" . ichoice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2397 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2398 | " Reconstruct Choice when choice starts with '"' |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2399 | if match(choice,"?") == 0 |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2400 | echomsg 'NetWrite Usage:"' |
| 2401 | echomsg ':Nwrite machine:path uses rcp' |
| 2402 | echomsg ':Nwrite "machine path" uses ftp with <.netrc>' |
| 2403 | echomsg ':Nwrite "machine id password path" uses ftp' |
| 2404 | echomsg ':Nwrite dav://[user@]machine/path uses cadaver' |
| 2405 | echomsg ':Nwrite fetch://[user@]machine/path uses fetch' |
| 2406 | echomsg ':Nwrite ftp://machine[#port]/path uses ftp (autodetects <.netrc>)' |
| 2407 | echomsg ':Nwrite rcp://machine/path uses rcp' |
| 2408 | echomsg ':Nwrite rsync://[user@]machine/path uses rsync' |
| 2409 | echomsg ':Nwrite scp://[user@]machine[[:#]port]/path uses scp' |
| 2410 | echomsg ':Nwrite sftp://[user@]machine/path uses sftp' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2411 | sleep 4 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2412 | break |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2413 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2414 | elseif match(choice,"^\"") != -1 |
| 2415 | if match(choice,"\"$") != -1 |
| 2416 | " case "..." |
| 2417 | let choice=strpart(choice,1,strlen(choice)-2) |
| 2418 | else |
| 2419 | " case "... ... ..." |
| 2420 | let choice = strpart(choice,1,strlen(choice)-1) |
| 2421 | let wholechoice = "" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2422 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2423 | while match(choice,"\"$") == -1 |
| 2424 | let wholechoice= wholechoice . " " . choice |
| 2425 | let ichoice = ichoice + 1 |
| 2426 | if choice > a:0 |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2427 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2428 | call netrw#ErrorMsg(s:ERROR,"Unbalanced string in filename '". wholechoice ."'",13) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2429 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2430 | " call Dret("netrw#NetWrite") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2431 | return |
| 2432 | endif |
| 2433 | let choice= a:{ichoice} |
| 2434 | endwhile |
| 2435 | let choice= strpart(wholechoice,1,strlen(wholechoice)-1) . " " . strpart(choice,0,strlen(choice)-1) |
| 2436 | endif |
| 2437 | endif |
| 2438 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2439 | let ichoice= ichoice + 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2440 | " call Decho("choice<" . choice . "> ichoice=".ichoice,'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2441 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2442 | " Determine method of write (ftp, rcp, etc) {{{4 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2443 | NetrwKeepj call s:NetrwMethod(choice) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2444 | if !exists("b:netrw_method") || b:netrw_method < 0 |
| 2445 | " call Dfunc("netrw#NetWrite : unsupported method") |
| 2446 | return |
| 2447 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2448 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2449 | " ============= |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2450 | " NetWrite: Perform Protocol-Based Write {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2451 | " ============================ |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2452 | if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 |
| 2453 | echo "(netrw) Processing your write request..." |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2454 | " call Decho("(netrw) Processing your write request...",'~'.expand("<slnum>")) |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2455 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2456 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2457 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2458 | " NetWrite: (rcp) NetWrite Method #1 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2459 | if b:netrw_method == 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2460 | " call Decho("write via rcp (method #1)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2461 | if s:netrw_has_nt_rcp == 1 |
| 2462 | if exists("g:netrw_uid") && ( g:netrw_uid != "" ) |
| 2463 | let uid_machine = g:netrw_machine .'.'. g:netrw_uid |
| 2464 | else |
| 2465 | let uid_machine = g:netrw_machine .'.'. $USERNAME |
| 2466 | endif |
| 2467 | else |
| 2468 | if exists("g:netrw_uid") && ( g:netrw_uid != "" ) |
| 2469 | let uid_machine = g:netrw_uid .'@'. g:netrw_machine |
| 2470 | else |
| 2471 | let uid_machine = g:netrw_machine |
| 2472 | endif |
| 2473 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2474 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_rcp_cmd." ".s:netrw_rcpmode." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(uid_machine.":".b:netrw_fname,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2475 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2476 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2477 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2478 | " NetWrite: (ftp + <.netrc>) NetWrite Method #2 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2479 | elseif b:netrw_method == 2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2480 | " call Decho("write via ftp+.netrc (method #2)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2481 | let netrw_fname = b:netrw_fname |
| 2482 | |
| 2483 | " formerly just a "new...bd!", that changed the window sizes when equalalways. Using enew workaround instead |
| 2484 | let bhkeep = &l:bh |
| 2485 | let curbuf = bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2486 | setl bh=hide |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2487 | keepj keepalt enew |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2488 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2489 | " call Decho("filter input window#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2490 | setl ff=unix |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2491 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2492 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2493 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2494 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2495 | " call Decho("filter input: ".getline("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2496 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2497 | NetrwKeepj call setline(line("$")+1,'put "'.tmpfile.'" "'.netrw_fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2498 | " call Decho("filter input: ".getline("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2499 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2500 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2501 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2502 | " call Decho("filter input window#".winnr(),'~'.expand("<slnum>")) |
| 2503 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2504 | endif |
| 2505 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
| 2506 | if getline(1) !~ "^$" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2507 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2508 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,getline(1),14) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2509 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2510 | let mod=1 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2511 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2512 | |
| 2513 | " remove enew buffer (quietly) |
| 2514 | let filtbuf= bufnr("%") |
| 2515 | exe curbuf."b!" |
| 2516 | let &l:bh = bhkeep |
| 2517 | exe filtbuf."bw!" |
| 2518 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2519 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2520 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2521 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2522 | " NetWrite: (ftp + machine, id, passwd, filename) NetWrite Method #3 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2523 | elseif b:netrw_method == 3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2524 | " Construct execution string (three or more lines) which will be passed through filter |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2525 | " call Decho("read via ftp+mipf (method #3)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2526 | let netrw_fname = b:netrw_fname |
| 2527 | let bhkeep = &l:bh |
| 2528 | |
| 2529 | " formerly just a "new...bd!", that changed the window sizes when equalalways. Using enew workaround instead |
| 2530 | let curbuf = bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2531 | setl bh=hide |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2532 | keepj keepalt enew |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2533 | setl ff=unix |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2534 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2535 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2536 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2537 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2538 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2539 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2540 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2541 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2542 | if exists("g:netrw_uid") && g:netrw_uid != "" |
| 2543 | if exists("g:netrw_ftp") && g:netrw_ftp == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2544 | NetrwKeepj put =g:netrw_uid |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2545 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2546 | if exists("s:netrw_passwd") && s:netrw_passwd != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2547 | NetrwKeepj put ='\"'.s:netrw_passwd.'\"' |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2548 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2549 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2550 | elseif exists("s:netrw_passwd") && s:netrw_passwd != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2551 | NetrwKeepj put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2552 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2553 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2554 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2555 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2556 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2557 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2558 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2559 | " call Decho("filter input: ".getline("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2560 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2561 | NetrwKeepj put ='put \"'.tmpfile.'\" \"'.netrw_fname.'\"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2562 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2563 | " save choice/id/password for future use |
| 2564 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2565 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2566 | " perform ftp: |
| 2567 | " -i : turns off interactive prompting from ftp |
| 2568 | " -n unix : DON'T use <.netrc>, even though it exists |
| 2569 | " -n win32: quit being obnoxious about password |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2570 | NetrwKeepj norm! 1Gdd |
| 2571 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." ".g:netrw_ftp_options) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2572 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
| 2573 | if getline(1) !~ "^$" |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2574 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2575 | call netrw#ErrorMsg(s:ERROR,getline(1),15) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2576 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2577 | let mod=1 |
| 2578 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2579 | |
| 2580 | " remove enew buffer (quietly) |
| 2581 | let filtbuf= bufnr("%") |
| 2582 | exe curbuf."b!" |
| 2583 | let &l:bh= bhkeep |
| 2584 | exe filtbuf."bw!" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2585 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2586 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2587 | " NetWrite: (scp) NetWrite Method #4 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2588 | elseif b:netrw_method == 4 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2589 | " call Decho("write via scp (method #4)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2590 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 2591 | let useport= " ".g:netrw_scpport." ".fnameescape(g:netrw_port) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2592 | else |
| 2593 | let useport= "" |
| 2594 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2595 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_scp_cmd.useport." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(g:netrw_machine.":".b:netrw_fname,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2596 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2597 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2598 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2599 | " NetWrite: (http) NetWrite Method #5 {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2600 | elseif b:netrw_method == 5 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2601 | " call Decho("write via http (method #5)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2602 | let curl= substitute(g:netrw_http_put_cmd,'\s\+.*$',"","") |
| 2603 | if executable(curl) |
| 2604 | let url= g:netrw_choice |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2605 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_http_put_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(url,1) ) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2606 | elseif !exists("g:netrw_quiet") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2607 | call netrw#ErrorMsg(s:ERROR,"can't write to http using <".g:netrw_http_put_cmd.">".",16) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 2608 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2609 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2610 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2611 | " NetWrite: (dav) NetWrite Method #6 (cadaver) {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2612 | elseif b:netrw_method == 6 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2613 | " call Decho("write via cadaver (method #6)",'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2614 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2615 | " Construct execution string (four lines) which will be passed through filter |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2616 | let netrw_fname = escape(b:netrw_fname,g:netrw_fname_escape) |
| 2617 | let bhkeep = &l:bh |
| 2618 | |
| 2619 | " formerly just a "new...bd!", that changed the window sizes when equalalways. Using enew workaround instead |
| 2620 | let curbuf = bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2621 | setl bh=hide |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2622 | keepj keepalt enew |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2623 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2624 | setl ff=unix |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2625 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2626 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2627 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2628 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2629 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2630 | if exists("g:netrw_uid") && exists("s:netrw_passwd") && g:netrw_uid != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2631 | NetrwKeepj put ='user '.g:netrw_uid.' '.s:netrw_passwd |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2632 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2633 | NetrwKeepj put ='put '.tmpfile.' '.netrw_fname |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2634 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2635 | " perform cadaver operation: |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2636 | NetrwKeepj norm! 1Gdd |
| 2637 | call s:NetrwExe(s:netrw_silentxfer."%!".g:netrw_dav_cmd) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2638 | |
| 2639 | " remove enew buffer (quietly) |
| 2640 | let filtbuf= bufnr("%") |
| 2641 | exe curbuf."b!" |
| 2642 | let &l:bh = bhkeep |
| 2643 | exe filtbuf."bw!" |
| 2644 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2645 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2646 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2647 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2648 | " NetWrite: (rsync) NetWrite Method #7 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2649 | elseif b:netrw_method == 7 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2650 | " call Decho("write via rsync (method #7)",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2651 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_rsync_cmd." ".s:ShellEscape(tmpfile,1)." ".s:ShellEscape(g:netrw_machine.g:netrw_rsync_sep.b:netrw_fname,1)) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2652 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2653 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2654 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2655 | " NetWrite: (sftp) NetWrite Method #9 {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2656 | elseif b:netrw_method == 9 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2657 | " call Decho("write via sftp (method #9)",'~'.expand("<slnum>")) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2658 | let netrw_fname= escape(b:netrw_fname,g:netrw_fname_escape) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2659 | if exists("g:netrw_uid") && ( g:netrw_uid != "" ) |
| 2660 | let uid_machine = g:netrw_uid .'@'. g:netrw_machine |
| 2661 | else |
| 2662 | let uid_machine = g:netrw_machine |
| 2663 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2664 | |
| 2665 | " formerly just a "new...bd!", that changed the window sizes when equalalways. Using enew workaround instead |
| 2666 | let bhkeep = &l:bh |
| 2667 | let curbuf = bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2668 | setl bh=hide |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2669 | keepj keepalt enew |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2670 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 2671 | setl ff=unix |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2672 | call setline(1,'put "'.escape(tmpfile,'\').'" '.netrw_fname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2673 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 2674 | let sftpcmd= substitute(g:netrw_sftp_cmd,"%TEMPFILE%",escape(tmpfile,'\'),"g") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2675 | call s:NetrwExe(s:netrw_silentxfer."%!".sftpcmd.' '.s:ShellEscape(uid_machine,1)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2676 | let filtbuf= bufnr("%") |
| 2677 | exe curbuf."b!" |
| 2678 | let &l:bh = bhkeep |
| 2679 | exe filtbuf."bw!" |
| 2680 | let b:netrw_lastfile = choice |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2681 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2682 | "......................................... |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2683 | " NetWrite: Complain {{{3 |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 2684 | else |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2685 | call netrw#ErrorMsg(s:WARNING,"unable to comply with your request<" . choice . ">",17) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 2686 | let leavemod= 1 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2687 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2688 | endwhile |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2689 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2690 | " NetWrite: Cleanup: {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2691 | " call Decho("cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2692 | if s:FileReadable(tmpfile) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2693 | " call Decho("tmpfile<".tmpfile."> readable, will now delete it",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 2694 | call s:NetrwDelete(tmpfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2695 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2696 | call s:NetrwOptionRestore("w:") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2697 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2698 | if a:firstline == 1 && a:lastline == line("$") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2699 | " restore modifiability; usually equivalent to set nomod |
| 2700 | let &mod= mod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2701 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 2702 | elseif !exists("leavemod") |
| 2703 | " indicate that the buffer has not been modified since last written |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2704 | " call Decho("set nomod",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2705 | setl nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2706 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2707 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2708 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2709 | " call Dret("netrw#NetWrite") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2710 | endfun |
| 2711 | |
| 2712 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2713 | " netrw#NetSource: source a remotely hosted vim script {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2714 | " uses NetRead to get a copy of the file into a temporarily file, |
| 2715 | " then sources that file, |
| 2716 | " then removes that file. |
| 2717 | fun! netrw#NetSource(...) |
| 2718 | " call Dfunc("netrw#NetSource() a:0=".a:0) |
| 2719 | if a:0 > 0 && a:1 == '?' |
| 2720 | " give help |
| 2721 | echomsg 'NetSource Usage:' |
| 2722 | echomsg ':Nsource dav://machine[:port]/path uses cadaver' |
| 2723 | echomsg ':Nsource fetch://machine/path uses fetch' |
| 2724 | echomsg ':Nsource ftp://[user@]machine[:port]/path uses ftp autodetects <.netrc>' |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 2725 | echomsg ':Nsource http[s]://[user@]machine/path uses http wget' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2726 | echomsg ':Nsource rcp://[user@]machine/path uses rcp' |
| 2727 | echomsg ':Nsource rsync://machine[:port]/path uses rsync' |
| 2728 | echomsg ':Nsource scp://[user@]machine[[:#]port]/path uses scp' |
| 2729 | echomsg ':Nsource sftp://[user@]machine[[:#]port]/path uses sftp' |
| 2730 | sleep 4 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2731 | else |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2732 | let i= 1 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2733 | while i <= a:0 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2734 | call netrw#NetRead(3,a:{i}) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2735 | " call Decho("s:netread_tmpfile<".s:netrw_tmpfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2736 | if s:FileReadable(s:netrw_tmpfile) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2737 | " call Decho("exe so ".fnameescape(s:netrw_tmpfile),'~'.expand("<slnum>")) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 2738 | exe "so ".fnameescape(s:netrw_tmpfile) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2739 | " call Decho("delete(".s:netrw_tmpfile.")",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 2740 | if delete(s:netrw_tmpfile) |
| 2741 | call netrw#ErrorMsg(s:ERROR,"unable to delete directory <".s:netrw_tmpfile.">!",103) |
| 2742 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2743 | unlet s:netrw_tmpfile |
| 2744 | else |
| 2745 | call netrw#ErrorMsg(s:ERROR,"unable to source <".a:{i}.">!",48) |
| 2746 | endif |
| 2747 | let i= i + 1 |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2748 | endwhile |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2749 | endif |
| 2750 | " call Dret("netrw#NetSource") |
| 2751 | endfun |
| 2752 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2753 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2754 | " netrw#SetTreetop: resets the tree top to the current directory/specified directory {{{2 |
| 2755 | " (implements the :Ntree command) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2756 | fun! netrw#SetTreetop(iscmd,...) |
| 2757 | " call Dfunc("netrw#SetTreetop(iscmd=".a:iscmd." ".((a:0 > 0)? a:1 : "").") a:0=".a:0) |
| 2758 | " call Decho("w:netrw_treetop<".w:netrw_treetop.">") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2759 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2760 | " iscmd==0: netrw#SetTreetop called using gn mapping |
| 2761 | " iscmd==1: netrw#SetTreetop called using :Ntree from the command line |
| 2762 | " call Decho("(iscmd=".a:iscmd.": called using :Ntree from command line",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2763 | " clear out the current tree |
| 2764 | if exists("w:netrw_treetop") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2765 | " call Decho("clearing out current tree",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2766 | let inittreetop= w:netrw_treetop |
| 2767 | unlet w:netrw_treetop |
| 2768 | endif |
| 2769 | if exists("w:netrw_treedict") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2770 | " call Decho("freeing w:netrw_treedict",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2771 | unlet w:netrw_treedict |
| 2772 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2773 | " call Decho("inittreetop<".(exists("inittreetop")? inittreetop : "n/a").">") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2774 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2775 | if (a:iscmd == 0 || a:1 == "") && exists("inittreetop") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2776 | let treedir= s:NetrwTreePath(inittreetop) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2777 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2778 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2779 | if isdirectory(s:NetrwFile(a:1)) |
| 2780 | " call Decho("a:1<".a:1."> is a directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2781 | let treedir= a:1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2782 | elseif exists("b:netrw_curdir") && (isdirectory(s:NetrwFile(b:netrw_curdir."/".a:1)) || a:1 =~ '^\a\{3,}://') |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2783 | let treedir= b:netrw_curdir."/".a:1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2784 | " call Decho("a:1<".a:1."> is NOT a directory, using treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2785 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2786 | " normally the cursor is left in the message window. |
| 2787 | " However, here this results in the directory being listed in the message window, which is not wanted. |
| 2788 | let netrwbuf= bufnr("%") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2789 | call netrw#ErrorMsg(s:ERROR,"sorry, ".a:1." doesn't seem to be a directory!",95) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2790 | exe bufwinnr(netrwbuf)."wincmd w" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2791 | let treedir= "." |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2792 | endif |
| 2793 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2794 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2795 | |
| 2796 | " determine if treedir is remote or local |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2797 | let islocal= expand("%") !~ '^\a\{3,}://' |
| 2798 | " call Decho("islocal=".islocal,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2799 | |
| 2800 | " browse the resulting directory |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2801 | if islocal |
| 2802 | call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(islocal,treedir)) |
| 2803 | else |
| 2804 | call s:NetrwBrowse(islocal,s:NetrwBrowseChgDir(islocal,treedir)) |
| 2805 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2806 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 2807 | " call Dret("netrw#SetTreetop") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2808 | endfun |
| 2809 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2810 | " =========================================== |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2811 | " s:NetrwGetFile: Function to read temporary file "tfile" with command "readcmd". {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2812 | " readcmd == %r : replace buffer with newly read file |
| 2813 | " == 0r : read file at top of buffer |
| 2814 | " == r : read file after current line |
| 2815 | " == t : leave file in temporary form (ie. don't read into buffer) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2816 | fun! s:NetrwGetFile(readcmd, tfile, method) |
| 2817 | " call Dfunc("NetrwGetFile(readcmd<".a:readcmd.">,tfile<".a:tfile."> method<".a:method.">)") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2818 | |
| 2819 | " readcmd=='t': simply do nothing |
| 2820 | if a:readcmd == 't' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2821 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2822 | " call Dret("NetrwGetFile : skip read of <".a:tfile.">") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2823 | return |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2824 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 2825 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2826 | " get name of remote filename (ie. url and all) |
| 2827 | let rfile= bufname("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2828 | " call Decho("rfile<".rfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 578b49e | 2005-09-10 19:22:57 +0000 | [diff] [blame] | 2829 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2830 | if exists("*NetReadFixup") |
| 2831 | " for the use of NetReadFixup (not otherwise used internally) |
| 2832 | let line2= line("$") |
Bram Moolenaar | 578b49e | 2005-09-10 19:22:57 +0000 | [diff] [blame] | 2833 | endif |
| 2834 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2835 | if a:readcmd[0] == '%' |
| 2836 | " get file into buffer |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2837 | " call Decho("get file into buffer",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2838 | |
| 2839 | " rename the current buffer to the temp file (ie. tfile) |
| 2840 | if g:netrw_cygwin |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2841 | let tfile= substitute(a:tfile,g:netrw_cygdrive.'/\(.\)','\1:','') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2842 | else |
| 2843 | let tfile= a:tfile |
| 2844 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2845 | call s:NetrwBufRename(tfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2846 | |
| 2847 | " edit temporary file (ie. read the temporary file in) |
| 2848 | if rfile =~ '\.zip$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2849 | " call Decho("handling remote zip file with zip#Browse(tfile<".tfile.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2850 | call zip#Browse(tfile) |
| 2851 | elseif rfile =~ '\.tar$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2852 | " call Decho("handling remote tar file with tar#Browse(tfile<".tfile.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2853 | call tar#Browse(tfile) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2854 | elseif rfile =~ '\.tar\.gz$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2855 | " call Decho("handling remote gzip-compressed tar file",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2856 | call tar#Browse(tfile) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2857 | elseif rfile =~ '\.tar\.bz2$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2858 | " call Decho("handling remote bz2-compressed tar file",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2859 | call tar#Browse(tfile) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2860 | elseif rfile =~ '\.tar\.xz$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2861 | " call Decho("handling remote xz-compressed tar file",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2862 | call tar#Browse(tfile) |
| 2863 | elseif rfile =~ '\.txz$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2864 | " call Decho("handling remote xz-compressed tar file (.txz)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 2865 | call tar#Browse(tfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2866 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2867 | " call Decho("edit temporary file",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2868 | NetrwKeepj e! |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2869 | endif |
| 2870 | |
| 2871 | " rename buffer back to remote filename |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2872 | call s:NetrwBufRename(rfile) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2873 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 2874 | " Detect filetype of local version of remote file. |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 2875 | " Note that isk must not include a "/" for scripts.vim |
| 2876 | " to process this detection correctly. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2877 | " call Decho("detect filetype of local version of remote file",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 2878 | let iskkeep= &l:isk |
| 2879 | setl isk-=/ |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 2880 | let &l:isk= iskkeep |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2881 | " call Dredir("ls!","NetrwGetFile (renamed buffer back to remote filename<".rfile."> : expand(%)<".expand("%").">)") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2882 | let line1 = 1 |
| 2883 | let line2 = line("$") |
| 2884 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2885 | elseif !&ma |
| 2886 | " attempting to read a file after the current line in the file, but the buffer is not modifiable |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2887 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"attempt to read<".a:tfile."> into a non-modifiable buffer!",94) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2888 | " call Dret("NetrwGetFile : attempt to read<".a:tfile."> into a non-modifiable buffer!") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 2889 | return |
| 2890 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2891 | elseif s:FileReadable(a:tfile) |
| 2892 | " read file after current line |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2893 | " call Decho("read file<".a:tfile."> after current line",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2894 | let curline = line(".") |
| 2895 | let lastline= line("$") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2896 | " call Decho("exe<".a:readcmd." ".fnameescape(v:cmdarg)." ".fnameescape(a:tfile)."> line#".curline,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2897 | exe "NetrwKeepj ".a:readcmd." ".fnameescape(v:cmdarg)." ".fnameescape(a:tfile) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2898 | let line1= curline + 1 |
| 2899 | let line2= line("$") - lastline + 1 |
| 2900 | |
| 2901 | else |
| 2902 | " not readable |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2903 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
| 2904 | " call Decho("tfile<".a:tfile."> not readable",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2905 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"file <".a:tfile."> not readable",9) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2906 | " call Dret("NetrwGetFile : tfile<".a:tfile."> not readable") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2907 | return |
| 2908 | endif |
| 2909 | |
| 2910 | " User-provided (ie. optional) fix-it-up command |
| 2911 | if exists("*NetReadFixup") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2912 | " call Decho("calling NetReadFixup(method<".a:method."> line1=".line1." line2=".line2.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2913 | NetrwKeepj call NetReadFixup(a:method, line1, line2) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2914 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2915 | " call Decho("NetReadFixup() not called, doesn't exist (line1=".line1." line2=".line2.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2916 | endif |
| 2917 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 2918 | if has("gui") && has("menu") && has("gui_running") && &go =~# 'm' && g:netrw_menu |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2919 | " update the Buffers menu |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2920 | NetrwKeepj call s:UpdateBuffersMenu() |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2921 | endif |
| 2922 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2923 | " call Decho("readcmd<".a:readcmd."> cmdarg<".v:cmdarg."> tfile<".a:tfile."> readable=".s:FileReadable(a:tfile),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2924 | |
| 2925 | " make sure file is being displayed |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2926 | " redraw! |
| 2927 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2928 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2929 | " call Dret("NetrwGetFile") |
Bram Moolenaar | 578b49e | 2005-09-10 19:22:57 +0000 | [diff] [blame] | 2930 | endfun |
| 2931 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 2932 | " ------------------------------------------------------------------------ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2933 | " s:NetrwMethod: determine method of transfer {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2934 | " Input: |
| 2935 | " choice = url [protocol:]//[userid@]hostname[:port]/[path-to-file] |
| 2936 | " Output: |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2937 | " b:netrw_method= 1: rcp |
| 2938 | " 2: ftp + <.netrc> |
| 2939 | " 3: ftp + machine, id, password, and [path]filename |
| 2940 | " 4: scp |
| 2941 | " 5: http[s] (wget) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2942 | " 6: dav |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2943 | " 7: rsync |
| 2944 | " 8: fetch |
| 2945 | " 9: sftp |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2946 | " 10: file |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2947 | " g:netrw_machine= hostname |
| 2948 | " b:netrw_fname = filename |
| 2949 | " g:netrw_port = optional port number (for ftp) |
| 2950 | " g:netrw_choice = copy of input url (choice) |
| 2951 | fun! s:NetrwMethod(choice) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2952 | " call Dfunc("s:NetrwMethod(a:choice<".a:choice.">)") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2953 | |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 2954 | " sanity check: choice should have at least three slashes in it |
| 2955 | if strlen(substitute(a:choice,'[^/]','','g')) < 3 |
| 2956 | call netrw#ErrorMsg(s:ERROR,"not a netrw-style url; netrw uses protocol://[user@]hostname[:port]/[path])",78) |
| 2957 | let b:netrw_method = -1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 2958 | " call Dret("s:NetrwMethod : incorrect url format<".a:choice.">") |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 2959 | return |
| 2960 | endif |
| 2961 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2962 | " record current g:netrw_machine, if any |
| 2963 | " curmachine used if protocol == ftp and no .netrc |
| 2964 | if exists("g:netrw_machine") |
| 2965 | let curmachine= g:netrw_machine |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 2966 | " call Decho("curmachine<".curmachine.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2967 | else |
| 2968 | let curmachine= "N O T A HOST" |
| 2969 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 2970 | if exists("g:netrw_port") |
| 2971 | let netrw_port= g:netrw_port |
| 2972 | endif |
| 2973 | |
| 2974 | " insure that netrw_ftp_cmd starts off every method determination |
| 2975 | " with the current g:netrw_ftp_cmd |
| 2976 | let s:netrw_ftp_cmd= g:netrw_ftp_cmd |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2977 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2978 | " initialization |
| 2979 | let b:netrw_method = 0 |
| 2980 | let g:netrw_machine = "" |
| 2981 | let b:netrw_fname = "" |
| 2982 | let g:netrw_port = "" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 2983 | let g:netrw_choice = a:choice |
| 2984 | |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2985 | " Patterns: |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 2986 | " mipf : a:machine a:id password filename Use ftp |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 2987 | " mf : a:machine filename Use ftp + <.netrc> or g:netrw_uid s:netrw_passwd |
| 2988 | " ftpurm : ftp://[user@]host[[#:]port]/filename Use ftp + <.netrc> or g:netrw_uid s:netrw_passwd |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 2989 | " rcpurm : rcp://[user@]host/filename Use rcp |
| 2990 | " rcphf : [user@]host:filename Use rcp |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2991 | " scpurm : scp://[user@]host[[#:]port]/filename Use scp |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 2992 | " httpurm : http[s]://[user@]host/filename Use wget |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 2993 | " davurm : dav[s]://host[:port]/path Use cadaver/curl |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2994 | " rsyncurm : rsync://host[:port]/path Use rsync |
| 2995 | " fetchurm : fetch://[user@]host[:http]/filename Use fetch (defaults to ftp, override for http) |
| 2996 | " sftpurm : sftp://[user@]host/filename Use scp |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 2997 | " fileurm : file://[user@]host/filename Use elinks or links |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 2998 | let mipf = '^\(\S\+\)\s\+\(\S\+\)\s\+\(\S\+\)\s\+\(\S\+\)$' |
| 2999 | let mf = '^\(\S\+\)\s\+\(\S\+\)$' |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3000 | let ftpurm = '^ftp://\(\([^/]*\)@\)\=\([^/#:]\{-}\)\([#:]\d\+\)\=/\(.*\)$' |
| 3001 | let rcpurm = '^rcp://\%(\([^/]*\)@\)\=\([^/]\{-}\)/\(.*\)$' |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3002 | let rcphf = '^\(\(\h\w*\)@\)\=\(\h\w*\):\([^@]\+\)$' |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 3003 | let scpurm = '^scp://\([^/#:]\+\)\%([#:]\(\d\+\)\)\=/\(.*\)$' |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3004 | let httpurm = '^https\=://\([^/]\{-}\)\(/.*\)\=$' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3005 | let davurm = '^davs\=://\([^/]\+\)/\(.*/\)\([-_.~[:alnum:]]\+\)$' |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3006 | let rsyncurm = '^rsync://\([^/]\{-}\)/\(.*\)\=$' |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3007 | let fetchurm = '^fetch://\(\([^/]*\)@\)\=\([^/#:]\{-}\)\(:http\)\=/\(.*\)$' |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3008 | let sftpurm = '^sftp://\([^/]\{-}\)/\(.*\)\=$' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3009 | let fileurm = '^file\=://\(.*\)$' |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3010 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3011 | " call Decho("determine method:",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3012 | " Determine Method |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3013 | " Method#1: rcp://user@hostname/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3014 | if match(a:choice,rcpurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3015 | " call Decho("rcp://...",'~'.expand("<slnum>")) |
Bram Moolenaar | 83bab71 | 2005-08-01 21:58:57 +0000 | [diff] [blame] | 3016 | let b:netrw_method = 1 |
| 3017 | let userid = substitute(a:choice,rcpurm,'\1',"") |
| 3018 | let g:netrw_machine = substitute(a:choice,rcpurm,'\2',"") |
| 3019 | let b:netrw_fname = substitute(a:choice,rcpurm,'\3',"") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3020 | if userid != "" |
| 3021 | let g:netrw_uid= userid |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3022 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3023 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3024 | " Method#4: scp://user@hostname/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3025 | elseif match(a:choice,scpurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3026 | " call Decho("scp://...",'~'.expand("<slnum>")) |
Bram Moolenaar | 578b49e | 2005-09-10 19:22:57 +0000 | [diff] [blame] | 3027 | let b:netrw_method = 4 |
Bram Moolenaar | 83bab71 | 2005-08-01 21:58:57 +0000 | [diff] [blame] | 3028 | let g:netrw_machine = substitute(a:choice,scpurm,'\1',"") |
| 3029 | let g:netrw_port = substitute(a:choice,scpurm,'\2',"") |
| 3030 | let b:netrw_fname = substitute(a:choice,scpurm,'\3',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3031 | |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3032 | " Method#5: http[s]://user@hostname/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3033 | elseif match(a:choice,httpurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3034 | " call Decho("http[s]://...",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3035 | let b:netrw_method = 5 |
| 3036 | let g:netrw_machine= substitute(a:choice,httpurm,'\1',"") |
| 3037 | let b:netrw_fname = substitute(a:choice,httpurm,'\2',"") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3038 | let b:netrw_http = (a:choice =~ '^https:')? "https" : "http" |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3039 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3040 | " Method#6: dav://hostname[:port]/..path-to-file.. {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3041 | elseif match(a:choice,davurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3042 | " call Decho("dav://...",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3043 | let b:netrw_method= 6 |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3044 | if a:choice =~ 'davs:' |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 3045 | let g:netrw_machine= 'https://'.substitute(a:choice,davurm,'\1/\2',"") |
| 3046 | else |
| 3047 | let g:netrw_machine= 'http://'.substitute(a:choice,davurm,'\1/\2',"") |
| 3048 | endif |
| 3049 | let b:netrw_fname = substitute(a:choice,davurm,'\3',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3050 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3051 | " Method#7: rsync://user@hostname/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3052 | elseif match(a:choice,rsyncurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3053 | " call Decho("rsync://...",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3054 | let b:netrw_method = 7 |
| 3055 | let g:netrw_machine= substitute(a:choice,rsyncurm,'\1',"") |
| 3056 | let b:netrw_fname = substitute(a:choice,rsyncurm,'\2',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3057 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3058 | " Methods 2,3: ftp://[user@]hostname[[:#]port]/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3059 | elseif match(a:choice,ftpurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3060 | " call Decho("ftp://...",'~'.expand("<slnum>")) |
Bram Moolenaar | 578b49e | 2005-09-10 19:22:57 +0000 | [diff] [blame] | 3061 | let userid = substitute(a:choice,ftpurm,'\2',"") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3062 | let g:netrw_machine= substitute(a:choice,ftpurm,'\3',"") |
| 3063 | let g:netrw_port = substitute(a:choice,ftpurm,'\4',"") |
| 3064 | let b:netrw_fname = substitute(a:choice,ftpurm,'\5',"") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3065 | " call Decho("g:netrw_machine<".g:netrw_machine.">",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3066 | if userid != "" |
| 3067 | let g:netrw_uid= userid |
| 3068 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3069 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3070 | if curmachine != g:netrw_machine |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3071 | if exists("s:netrw_hup[".g:netrw_machine."]") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3072 | call NetUserPass("ftp:".g:netrw_machine) |
| 3073 | elseif exists("s:netrw_passwd") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3074 | " if there's a change in hostname, require password re-entry |
| 3075 | unlet s:netrw_passwd |
| 3076 | endif |
| 3077 | if exists("netrw_port") |
| 3078 | unlet netrw_port |
| 3079 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3080 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3081 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3082 | if exists("g:netrw_uid") && exists("s:netrw_passwd") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3083 | let b:netrw_method = 3 |
| 3084 | else |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3085 | let host= substitute(g:netrw_machine,'\..*$','','') |
| 3086 | if exists("s:netrw_hup[host]") |
| 3087 | call NetUserPass("ftp:".host) |
| 3088 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3089 | elseif (has("win32") || has("win95") || has("win64") || has("win16")) && s:netrw_ftp_cmd =~# '-[sS]:' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3090 | " call Decho("has -s: : s:netrw_ftp_cmd<".s:netrw_ftp_cmd.">",'~'.expand("<slnum>")) |
| 3091 | " call Decho(" g:netrw_ftp_cmd<".g:netrw_ftp_cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3092 | if g:netrw_ftp_cmd =~# '-[sS]:\S*MACHINE\>' |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 3093 | let s:netrw_ftp_cmd= substitute(g:netrw_ftp_cmd,'\<MACHINE\>',g:netrw_machine,'') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3094 | " call Decho("s:netrw_ftp_cmd<".s:netrw_ftp_cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3095 | endif |
| 3096 | let b:netrw_method= 2 |
| 3097 | elseif s:FileReadable(expand("$HOME/.netrc")) && !g:netrw_ignorenetrc |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3098 | " call Decho("using <".expand("$HOME/.netrc")."> (readable)",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3099 | let b:netrw_method= 2 |
| 3100 | else |
| 3101 | if !exists("g:netrw_uid") || g:netrw_uid == "" |
| 3102 | call NetUserPass() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3103 | elseif !exists("s:netrw_passwd") || s:netrw_passwd == "" |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3104 | call NetUserPass(g:netrw_uid) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3105 | " else just use current g:netrw_uid and s:netrw_passwd |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3106 | endif |
| 3107 | let b:netrw_method= 3 |
| 3108 | endif |
| 3109 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3110 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3111 | " Method#8: fetch {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3112 | elseif match(a:choice,fetchurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3113 | " call Decho("fetch://...",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3114 | let b:netrw_method = 8 |
| 3115 | let g:netrw_userid = substitute(a:choice,fetchurm,'\2',"") |
| 3116 | let g:netrw_machine= substitute(a:choice,fetchurm,'\3',"") |
| 3117 | let b:netrw_option = substitute(a:choice,fetchurm,'\4',"") |
| 3118 | let b:netrw_fname = substitute(a:choice,fetchurm,'\5',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3119 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3120 | " Method#3: Issue an ftp : "machine id password [path/]filename" {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3121 | elseif match(a:choice,mipf) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3122 | " call Decho("(ftp) host id pass file",'~'.expand("<slnum>")) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3123 | let b:netrw_method = 3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3124 | let g:netrw_machine = substitute(a:choice,mipf,'\1',"") |
| 3125 | let g:netrw_uid = substitute(a:choice,mipf,'\2',"") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3126 | let s:netrw_passwd = substitute(a:choice,mipf,'\3',"") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3127 | let b:netrw_fname = substitute(a:choice,mipf,'\4',"") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3128 | call NetUserPass(g:netrw_machine,g:netrw_uid,s:netrw_passwd) |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3129 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3130 | " Method#3: Issue an ftp: "hostname [path/]filename" {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3131 | elseif match(a:choice,mf) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3132 | " call Decho("(ftp) host file",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3133 | if exists("g:netrw_uid") && exists("s:netrw_passwd") |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3134 | let b:netrw_method = 3 |
| 3135 | let g:netrw_machine = substitute(a:choice,mf,'\1',"") |
| 3136 | let b:netrw_fname = substitute(a:choice,mf,'\2',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3137 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3138 | elseif s:FileReadable(expand("$HOME/.netrc")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3139 | let b:netrw_method = 2 |
| 3140 | let g:netrw_machine = substitute(a:choice,mf,'\1',"") |
| 3141 | let b:netrw_fname = substitute(a:choice,mf,'\2',"") |
| 3142 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3143 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3144 | " Method#9: sftp://user@hostname/...path-to-file {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3145 | elseif match(a:choice,sftpurm) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3146 | " call Decho("sftp://...",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3147 | let b:netrw_method = 9 |
| 3148 | let g:netrw_machine= substitute(a:choice,sftpurm,'\1',"") |
| 3149 | let b:netrw_fname = substitute(a:choice,sftpurm,'\2',"") |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3150 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3151 | " Method#1: Issue an rcp: hostname:filename" (this one should be last) {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3152 | elseif match(a:choice,rcphf) == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3153 | " call Decho("(rcp) [user@]host:file) rcphf<".rcphf.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3154 | let b:netrw_method = 1 |
| 3155 | let userid = substitute(a:choice,rcphf,'\2',"") |
| 3156 | let g:netrw_machine = substitute(a:choice,rcphf,'\3',"") |
| 3157 | let b:netrw_fname = substitute(a:choice,rcphf,'\4',"") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3158 | " call Decho('\1<'.substitute(a:choice,rcphf,'\1',"").">",'~'.expand("<slnum>")) |
| 3159 | " call Decho('\2<'.substitute(a:choice,rcphf,'\2',"").">",'~'.expand("<slnum>")) |
| 3160 | " call Decho('\3<'.substitute(a:choice,rcphf,'\3',"").">",'~'.expand("<slnum>")) |
| 3161 | " call Decho('\4<'.substitute(a:choice,rcphf,'\4',"").">",'~'.expand("<slnum>")) |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3162 | if userid != "" |
| 3163 | let g:netrw_uid= userid |
| 3164 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3165 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3166 | " Method#10: file://user@hostname/...path-to-file {{{3 |
| 3167 | elseif match(a:choice,fileurm) == 0 && exists("g:netrw_file_cmd") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3168 | " call Decho("http[s]://...",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3169 | let b:netrw_method = 10 |
| 3170 | let b:netrw_fname = substitute(a:choice,fileurm,'\1',"") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3171 | " call Decho('\1<'.substitute(a:choice,fileurm,'\1',"").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3172 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3173 | " Cannot Determine Method {{{3 |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3174 | else |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 3175 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3176 | call netrw#ErrorMsg(s:WARNING,"cannot determine method (format: protocol://[user@]hostname[:port]/[path])",45) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 3177 | endif |
Bram Moolenaar | f4b8e57 | 2004-06-24 15:53:16 +0000 | [diff] [blame] | 3178 | let b:netrw_method = -1 |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3179 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3180 | "}}}3 |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3181 | |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3182 | if g:netrw_port != "" |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3183 | " remove any leading [:#] from port number |
| 3184 | let g:netrw_port = substitute(g:netrw_port,'[#:]\+','','') |
| 3185 | elseif exists("netrw_port") |
| 3186 | " retain port number as implicit for subsequent ftp operations |
| 3187 | let g:netrw_port= netrw_port |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3188 | endif |
Bram Moolenaar | 4ea8fe1 | 2006-03-09 22:32:39 +0000 | [diff] [blame] | 3189 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3190 | " call Decho("a:choice <".a:choice.">",'~'.expand("<slnum>")) |
| 3191 | " call Decho("b:netrw_method <".b:netrw_method.">",'~'.expand("<slnum>")) |
| 3192 | " call Decho("g:netrw_machine<".g:netrw_machine.">",'~'.expand("<slnum>")) |
| 3193 | " call Decho("g:netrw_port <".g:netrw_port.">",'~'.expand("<slnum>")) |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 3194 | " if exists("g:netrw_uid") "Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3195 | " call Decho("g:netrw_uid <".g:netrw_uid.">",'~'.expand("<slnum>")) |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 3196 | " endif "Decho |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3197 | " if exists("s:netrw_passwd") "Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3198 | " call Decho("s:netrw_passwd <".s:netrw_passwd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 3199 | " endif "Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3200 | " call Decho("b:netrw_fname <".b:netrw_fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3201 | " call Dret("s:NetrwMethod : b:netrw_method=".b:netrw_method." g:netrw_port=".g:netrw_port) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3202 | endfun |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3203 | |
| 3204 | " ------------------------------------------------------------------------ |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3205 | " NetReadFixup: this sort of function is typically written by the user {{{2 |
| 3206 | " to handle extra junk that their system's ftp dumps |
| 3207 | " into the transfer. This function is provided as an |
| 3208 | " example and as a fix for a Windows 95 problem: in my |
| 3209 | " experience, win95's ftp always dumped four blank lines |
| 3210 | " at the end of the transfer. |
| 3211 | if has("win95") && exists("g:netrw_win95ftp") && g:netrw_win95ftp |
| 3212 | fun! NetReadFixup(method, line1, line2) |
| 3213 | " call Dfunc("NetReadFixup(method<".a:method."> line1=".a:line1." line2=".a:line2.")") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3214 | |
| 3215 | " sanity checks -- attempt to convert inputs to integers |
| 3216 | let method = a:method + 0 |
| 3217 | let line1 = a:line1 + 0 |
| 3218 | let line2 = a:line2 + 0 |
| 3219 | if type(method) != 0 || type(line1) != 0 || type(line2) != 0 || method < 0 || line1 <= 0 || line2 <= 0 |
| 3220 | " call Dret("NetReadFixup") |
| 3221 | return |
| 3222 | endif |
| 3223 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3224 | if method == 3 " ftp (no <.netrc>) |
| 3225 | let fourblanklines= line2 - 3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3226 | if fourblanklines >= line1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3227 | exe "sil NetrwKeepj ".fourblanklines.",".line2."g/^\s*$/d" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3228 | call histdel("/",-1) |
| 3229 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3230 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3231 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3232 | " call Dret("NetReadFixup") |
| 3233 | endfun |
| 3234 | endif |
| 3235 | |
| 3236 | " --------------------------------------------------------------------- |
Bram Moolenaar | afeb4fa | 2006-02-01 21:51:12 +0000 | [diff] [blame] | 3237 | " NetUserPass: set username and password for subsequent ftp transfer {{{2 |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3238 | " Usage: :call NetUserPass() -- will prompt for userid and password |
| 3239 | " :call NetUserPass("uid") -- will prompt for password |
| 3240 | " :call NetUserPass("uid","password") -- sets global userid and password |
| 3241 | " :call NetUserPass("ftp:host") -- looks up userid and password using hup dictionary |
| 3242 | " :call NetUserPass("host","uid","password") -- sets hup dictionary with host, userid, password |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3243 | fun! NetUserPass(...) |
| 3244 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3245 | " call Dfunc("NetUserPass() a:0=".a:0) |
| 3246 | |
| 3247 | if !exists('s:netrw_hup') |
| 3248 | let s:netrw_hup= {} |
| 3249 | endif |
| 3250 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3251 | if a:0 == 0 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3252 | " case: no input arguments |
| 3253 | |
| 3254 | " change host and username if not previously entered; get new password |
| 3255 | if !exists("g:netrw_machine") |
| 3256 | let g:netrw_machine= input('Enter hostname: ') |
| 3257 | endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3258 | if !exists("g:netrw_uid") || g:netrw_uid == "" |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3259 | " get username (user-id) via prompt |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3260 | let g:netrw_uid= input('Enter username: ') |
| 3261 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3262 | " get password via prompting |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3263 | let s:netrw_passwd= inputsecret("Enter Password: ") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3264 | |
| 3265 | " set up hup database |
| 3266 | let host = substitute(g:netrw_machine,'\..*$','','') |
| 3267 | if !exists('s:netrw_hup[host]') |
| 3268 | let s:netrw_hup[host]= {} |
| 3269 | endif |
| 3270 | let s:netrw_hup[host].uid = g:netrw_uid |
| 3271 | let s:netrw_hup[host].passwd = s:netrw_passwd |
| 3272 | |
| 3273 | elseif a:0 == 1 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3274 | " case: one input argument |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3275 | |
| 3276 | if a:1 =~ '^ftp:' |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3277 | " get host from ftp:... url |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3278 | " access userid and password from hup (host-user-passwd) dictionary |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3279 | " call Decho("case a:0=1: a:1<".a:1."> (get host from ftp:... url)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3280 | let host = substitute(a:1,'^ftp:','','') |
| 3281 | let host = substitute(host,'\..*','','') |
| 3282 | if exists("s:netrw_hup[host]") |
| 3283 | let g:netrw_uid = s:netrw_hup[host].uid |
| 3284 | let s:netrw_passwd = s:netrw_hup[host].passwd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3285 | " call Decho("get s:netrw_hup[".host."].uid <".s:netrw_hup[host].uid.">",'~'.expand("<slnum>")) |
| 3286 | " call Decho("get s:netrw_hup[".host."].passwd<".s:netrw_hup[host].passwd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3287 | else |
| 3288 | let g:netrw_uid = input("Enter UserId: ") |
| 3289 | let s:netrw_passwd = inputsecret("Enter Password: ") |
| 3290 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3291 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3292 | else |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3293 | " case: one input argument, not an url. Using it as a new user-id. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3294 | " call Decho("case a:0=1: a:1<".a:1."> (get host from input argument, not an url)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3295 | if exists("g:netrw_machine") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3296 | if g:netrw_machine =~ '[0-9.]\+' |
| 3297 | let host= g:netrw_machine |
| 3298 | else |
| 3299 | let host= substitute(g:netrw_machine,'\..*$','','') |
| 3300 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3301 | else |
| 3302 | let g:netrw_machine= input('Enter hostname: ') |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3303 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3304 | let g:netrw_uid = a:1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3305 | " call Decho("set g:netrw_uid= <".g:netrw_uid.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3306 | if exists("g:netrw_passwd") |
| 3307 | " ask for password if one not previously entered |
| 3308 | let s:netrw_passwd= g:netrw_passwd |
| 3309 | else |
| 3310 | let s:netrw_passwd = inputsecret("Enter Password: ") |
| 3311 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3312 | endif |
| 3313 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3314 | " call Decho("host<".host.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3315 | if exists("host") |
| 3316 | if !exists('s:netrw_hup[host]') |
| 3317 | let s:netrw_hup[host]= {} |
| 3318 | endif |
| 3319 | let s:netrw_hup[host].uid = g:netrw_uid |
| 3320 | let s:netrw_hup[host].passwd = s:netrw_passwd |
| 3321 | endif |
| 3322 | |
| 3323 | elseif a:0 == 2 |
| 3324 | let g:netrw_uid = a:1 |
| 3325 | let s:netrw_passwd = a:2 |
| 3326 | |
| 3327 | elseif a:0 == 3 |
| 3328 | " enter hostname, user-id, and password into the hup dictionary |
| 3329 | let host = substitute(a:1,'^\a\+:','','') |
| 3330 | let host = substitute(host,'\..*$','','') |
| 3331 | if !exists('s:netrw_hup[host]') |
| 3332 | let s:netrw_hup[host]= {} |
| 3333 | endif |
| 3334 | let s:netrw_hup[host].uid = a:2 |
| 3335 | let s:netrw_hup[host].passwd = a:3 |
| 3336 | let g:netrw_uid = s:netrw_hup[host].uid |
| 3337 | let s:netrw_passwd = s:netrw_hup[host].passwd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3338 | " call Decho("set s:netrw_hup[".host."].uid <".s:netrw_hup[host].uid.">",'~'.expand("<slnum>")) |
| 3339 | " call Decho("set s:netrw_hup[".host."].passwd<".s:netrw_hup[host].passwd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3340 | endif |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 3341 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3342 | " call Dret("NetUserPass : uid<".g:netrw_uid."> passwd<".s:netrw_passwd.">") |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3343 | endfun |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3344 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3345 | " ================================= |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3346 | " Shared Browsing Support: {{{1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3347 | " ================================= |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3348 | |
Bram Moolenaar | 69a7cb4 | 2004-06-20 12:51:53 +0000 | [diff] [blame] | 3349 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3350 | " s:ExplorePatHls: converts an Explore pattern into a regular expression search pattern {{{2 |
| 3351 | fun! s:ExplorePatHls(pattern) |
| 3352 | " call Dfunc("s:ExplorePatHls(pattern<".a:pattern.">)") |
| 3353 | let repat= substitute(a:pattern,'^**/\{1,2}','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3354 | " call Decho("repat<".repat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3355 | let repat= escape(repat,'][.\') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3356 | " call Decho("repat<".repat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3357 | let repat= '\<'.substitute(repat,'\*','\\(\\S\\+ \\)*\\S\\+','g').'\>' |
| 3358 | " call Dret("s:ExplorePatHls repat<".repat.">") |
| 3359 | return repat |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3360 | endfun |
| 3361 | |
| 3362 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3363 | " s:NetrwBookHistHandler: {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3364 | " 0: (user: <mb>) bookmark current directory |
| 3365 | " 1: (user: <gb>) change to the bookmarked directory |
| 3366 | " 2: (user: <qb>) list bookmarks |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3367 | " 3: (browsing) records current directory history |
| 3368 | " 4: (user: <u>) go up (previous) directory, using history |
| 3369 | " 5: (user: <U>) go down (next) directory, using history |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3370 | " 6: (user: <mB>) delete bookmark |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3371 | fun! s:NetrwBookHistHandler(chg,curdir) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 3372 | " call Dfunc("s:NetrwBookHistHandler(chg=".a:chg." curdir<".a:curdir.">) cnt=".v:count." histcnt=".g:netrw_dirhist_cnt." histmax=".g:netrw_dirhistmax) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3373 | if !exists("g:netrw_dirhistmax") || g:netrw_dirhistmax <= 0 |
| 3374 | " " call Dret("s:NetrwBookHistHandler - suppressed due to g:netrw_dirhistmax") |
| 3375 | return |
| 3376 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3377 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3378 | let ykeep = @@ |
| 3379 | let curbufnr = bufnr("%") |
| 3380 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3381 | if a:chg == 0 |
| 3382 | " bookmark the current directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3383 | " call Decho("(user: <b>) bookmark the current directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3384 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 3385 | call s:NetrwBookmark(0) |
| 3386 | echo "bookmarked marked files" |
| 3387 | else |
| 3388 | call s:MakeBookmark(a:curdir) |
| 3389 | echo "bookmarked the current directory" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3390 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3391 | |
| 3392 | elseif a:chg == 1 |
| 3393 | " change to the bookmarked directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3394 | " call Decho("(user: <".v:count."gb>) change to the bookmarked directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3395 | if exists("g:netrw_bookmarklist[v:count-1]") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3396 | " call Decho("(user: <".v:count."gb>) bookmarklist=".string(g:netrw_bookmarklist),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3397 | exe "NetrwKeepj e ".fnameescape(g:netrw_bookmarklist[v:count-1]) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3398 | else |
| 3399 | echomsg "Sorry, bookmark#".v:count." doesn't exist!" |
| 3400 | endif |
| 3401 | |
| 3402 | elseif a:chg == 2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3403 | " redraw! |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3404 | let didwork= 0 |
| 3405 | " list user's bookmarks |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3406 | " call Decho("(user: <q>) list user's bookmarks",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3407 | if exists("g:netrw_bookmarklist") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3408 | " call Decho('list '.len(g:netrw_bookmarklist).' bookmarks','~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3409 | let cnt= 1 |
| 3410 | for bmd in g:netrw_bookmarklist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3411 | " call Decho("Netrw Bookmark#".cnt.": ".g:netrw_bookmarklist[cnt-1],'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3412 | echo printf("Netrw Bookmark#%-2d: %s",cnt,g:netrw_bookmarklist[cnt-1]) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3413 | let didwork = 1 |
| 3414 | let cnt = cnt + 1 |
| 3415 | endfor |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3416 | endif |
| 3417 | |
| 3418 | " list directory history |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3419 | let cnt = g:netrw_dirhist_cnt |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3420 | let first = 1 |
| 3421 | let histcnt = 0 |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3422 | if g:netrw_dirhistmax > 0 |
| 3423 | while ( first || cnt != g:netrw_dirhist_cnt ) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3424 | " call Decho("first=".first." cnt=".cnt." dirhist_cnt=".g:netrw_dirhist_cnt,'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3425 | if exists("g:netrw_dirhist_{cnt}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3426 | " call Decho("Netrw History#".histcnt.": ".g:netrw_dirhist_{cnt},'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3427 | echo printf("Netrw History#%-2d: %s",histcnt,g:netrw_dirhist_{cnt}) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3428 | let didwork= 1 |
| 3429 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3430 | let histcnt = histcnt + 1 |
| 3431 | let first = 0 |
| 3432 | let cnt = ( cnt - 1 ) % g:netrw_dirhistmax |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3433 | if cnt < 0 |
| 3434 | let cnt= cnt + g:netrw_dirhistmax |
| 3435 | endif |
| 3436 | endwhile |
| 3437 | else |
| 3438 | let g:netrw_dirhist_cnt= 0 |
| 3439 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3440 | if didwork |
| 3441 | call inputsave()|call input("Press <cr> to continue")|call inputrestore() |
| 3442 | endif |
| 3443 | |
| 3444 | elseif a:chg == 3 |
| 3445 | " saves most recently visited directories (when they differ) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3446 | " call Decho("(browsing) record curdir history",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3447 | if !exists("g:netrw_dirhist_cnt") || !exists("g:netrw_dirhist_{g:netrw_dirhist_cnt}") || g:netrw_dirhist_{g:netrw_dirhist_cnt} != a:curdir |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3448 | if g:netrw_dirhistmax > 0 |
| 3449 | let g:netrw_dirhist_cnt = ( g:netrw_dirhist_cnt + 1 ) % g:netrw_dirhistmax |
| 3450 | let g:netrw_dirhist_{g:netrw_dirhist_cnt} = a:curdir |
| 3451 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3452 | " call Decho("save dirhist#".g:netrw_dirhist_cnt."<".g:netrw_dirhist_{g:netrw_dirhist_cnt}.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3453 | endif |
| 3454 | |
| 3455 | elseif a:chg == 4 |
| 3456 | " u: change to the previous directory stored on the history list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3457 | " call Decho("(user: <u>) chg to prev dir from history",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3458 | if g:netrw_dirhistmax > 0 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3459 | let g:netrw_dirhist_cnt= ( g:netrw_dirhist_cnt - v:count1 ) % g:netrw_dirhistmax |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3460 | if g:netrw_dirhist_cnt < 0 |
| 3461 | let g:netrw_dirhist_cnt= g:netrw_dirhist_cnt + g:netrw_dirhistmax |
| 3462 | endif |
| 3463 | else |
| 3464 | let g:netrw_dirhist_cnt= 0 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3465 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3466 | if exists("g:netrw_dirhist_{g:netrw_dirhist_cnt}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3467 | " call Decho("changedir u#".g:netrw_dirhist_cnt."<".g:netrw_dirhist_{g:netrw_dirhist_cnt}.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3468 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("b:netrw_curdir") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3469 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3470 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
| 3471 | sil! NetrwKeepj %d _ |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3472 | setl nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3473 | " call Decho("setl nomod",'~'.expand("<slnum>")) |
| 3474 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3475 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3476 | " call Decho("exe e! ".fnameescape(g:netrw_dirhist_{g:netrw_dirhist_cnt}),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3477 | exe "NetrwKeepj e! ".fnameescape(g:netrw_dirhist_{g:netrw_dirhist_cnt}) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3478 | else |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3479 | if g:netrw_dirhistmax > 0 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3480 | let g:netrw_dirhist_cnt= ( g:netrw_dirhist_cnt + v:count1 ) % g:netrw_dirhistmax |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3481 | else |
| 3482 | let g:netrw_dirhist_cnt= 0 |
| 3483 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3484 | echo "Sorry, no predecessor directory exists yet" |
| 3485 | endif |
| 3486 | |
| 3487 | elseif a:chg == 5 |
| 3488 | " U: change to the subsequent directory stored on the history list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3489 | " call Decho("(user: <U>) chg to next dir from history",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3490 | if g:netrw_dirhistmax > 0 |
| 3491 | let g:netrw_dirhist_cnt= ( g:netrw_dirhist_cnt + 1 ) % g:netrw_dirhistmax |
| 3492 | if exists("g:netrw_dirhist_{g:netrw_dirhist_cnt}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3493 | " call Decho("changedir U#".g:netrw_dirhist_cnt."<".g:netrw_dirhist_{g:netrw_dirhist_cnt}.">",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3494 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("b:netrw_curdir") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3495 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3496 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3497 | sil! NetrwKeepj %d _ |
| 3498 | " call Decho("removed all lines from buffer (%d)",'~'.expand("<slnum>")) |
| 3499 | " call Decho("setl nomod",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3500 | setl nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3501 | " call Decho("(set nomod) ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3502 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3503 | " call Decho("exe e! ".fnameescape(g:netrw_dirhist_{g:netrw_dirhist_cnt}),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3504 | exe "NetrwKeepj e! ".fnameescape(g:netrw_dirhist_{g:netrw_dirhist_cnt}) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3505 | else |
| 3506 | let g:netrw_dirhist_cnt= ( g:netrw_dirhist_cnt - 1 ) % g:netrw_dirhistmax |
| 3507 | if g:netrw_dirhist_cnt < 0 |
| 3508 | let g:netrw_dirhist_cnt= g:netrw_dirhist_cnt + g:netrw_dirhistmax |
| 3509 | endif |
| 3510 | echo "Sorry, no successor directory exists yet" |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3511 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3512 | else |
| 3513 | let g:netrw_dirhist_cnt= 0 |
| 3514 | echo "Sorry, no successor directory exists yet (g:netrw_dirhistmax is ".g:netrw_dirhistmax.")" |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3515 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3516 | |
| 3517 | elseif a:chg == 6 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3518 | " call Decho("(user: <mB>) delete bookmark'd directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3519 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 3520 | call s:NetrwBookmark(1) |
| 3521 | echo "removed marked files from bookmarks" |
| 3522 | else |
| 3523 | " delete the v:count'th bookmark |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3524 | let iremove = v:count |
| 3525 | let dremove = g:netrw_bookmarklist[iremove - 1] |
| 3526 | " call Decho("delete bookmark#".iremove."<".g:netrw_bookmarklist[iremove - 1].">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3527 | call s:MergeBookmarks() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3528 | " call Decho("remove g:netrw_bookmarklist[".(iremove-1)."]<".g:netrw_bookmarklist[(iremove-1)].">",'~'.expand("<slnum>")) |
| 3529 | NetrwKeepj call remove(g:netrw_bookmarklist,iremove-1) |
| 3530 | echo "removed ".dremove." from g:netrw_bookmarklist" |
| 3531 | " call Decho("g:netrw_bookmarklist=".string(g:netrw_bookmarklist),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3532 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3533 | " call Decho("resulting g:netrw_bookmarklist=".string(g:netrw_bookmarklist),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3534 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3535 | call s:NetrwBookmarkMenu() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3536 | call s:NetrwTgtMenu() |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3537 | let @@= ykeep |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 3538 | " call Dret("s:NetrwBookHistHandler") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3539 | endfun |
| 3540 | |
| 3541 | " --------------------------------------------------------------------- |
| 3542 | " s:NetrwBookHistRead: this function reads bookmarks and history {{{2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3543 | " Will source the history file (.netrwhist) only if the g:netrw_disthistmax is > 0. |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3544 | " Sister function: s:NetrwBookHistSave() |
| 3545 | fun! s:NetrwBookHistRead() |
| 3546 | " call Dfunc("s:NetrwBookHistRead()") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3547 | if !exists("g:netrw_dirhistmax") || g:netrw_dirhistmax <= 0 |
| 3548 | " " call Dret("s:NetrwBookHistRead - suppressed due to g:netrw_dirhistmax") |
| 3549 | return |
| 3550 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3551 | let ykeep= @@ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3552 | if !exists("s:netrw_initbookhist") |
| 3553 | let home = s:NetrwHome() |
| 3554 | let savefile= home."/.netrwbook" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3555 | if filereadable(s:NetrwFile(savefile)) |
| 3556 | " call Decho("sourcing .netrwbook",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3557 | exe "keepalt NetrwKeepj so ".savefile |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3558 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3559 | if g:netrw_dirhistmax > 0 |
| 3560 | let savefile= home."/.netrwhist" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3561 | if filereadable(s:NetrwFile(savefile)) |
| 3562 | " call Decho("sourcing .netrwhist",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3563 | exe "keepalt NetrwKeepj so ".savefile |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3564 | endif |
| 3565 | let s:netrw_initbookhist= 1 |
| 3566 | au VimLeave * call s:NetrwBookHistSave() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3567 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3568 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3569 | let @@= ykeep |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3570 | " call Dret("s:NetrwBookHistRead") |
| 3571 | endfun |
| 3572 | |
| 3573 | " --------------------------------------------------------------------- |
| 3574 | " s:NetrwBookHistSave: this function saves bookmarks and history {{{2 |
| 3575 | " Sister function: s:NetrwBookHistRead() |
| 3576 | " I used to do this via viminfo but that appears to |
| 3577 | " be unreliable for long-term storage |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3578 | " If g:netrw_dirhistmax is <= 0, no history or bookmarks |
| 3579 | " will be saved. |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3580 | fun! s:NetrwBookHistSave() |
| 3581 | " call Dfunc("s:NetrwBookHistSave() dirhistmax=".g:netrw_dirhistmax) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3582 | if !exists("g:netrw_dirhistmax") || g:netrw_dirhistmax <= 0 |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3583 | " call Dret("s:NetrwBookHistSave : dirhistmax=".g:netrw_dirhistmax) |
| 3584 | return |
| 3585 | endif |
| 3586 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3587 | let savefile= s:NetrwHome()."/.netrwhist" |
| 3588 | 1split |
| 3589 | call s:NetrwEnew() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3590 | if g:netrw_use_noswf |
| 3591 | setl cino= com= cpo-=a cpo-=A fo=nroql2 tw=0 report=10000 noswf |
| 3592 | else |
| 3593 | setl cino= com= cpo-=a cpo-=A fo=nroql2 tw=0 report=10000 |
| 3594 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3595 | setl nocin noai noci magic nospell nohid wig= noaw |
| 3596 | setl ma noro write |
| 3597 | if exists("+acd") | setl noacd | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3598 | sil! NetrwKeepj keepalt %d _ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3599 | |
| 3600 | " save .netrwhist -- no attempt to merge |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3601 | sil! keepalt file .netrwhist |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3602 | call setline(1,"let g:netrw_dirhistmax =".g:netrw_dirhistmax) |
| 3603 | call setline(2,"let g:netrw_dirhist_cnt =".g:netrw_dirhist_cnt) |
| 3604 | let lastline = line("$") |
| 3605 | let cnt = 1 |
| 3606 | while cnt <= g:netrw_dirhist_cnt |
| 3607 | call setline((cnt+lastline),'let g:netrw_dirhist_'.cnt."='".g:netrw_dirhist_{cnt}."'") |
| 3608 | let cnt= cnt + 1 |
| 3609 | endwhile |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 3610 | exe "sil! w! ".savefile |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3611 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3612 | sil NetrwKeepj %d _ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3613 | if exists("g:netrw_bookmarklist") && g:netrw_bookmarklist != [] |
| 3614 | " merge and write .netrwbook |
| 3615 | let savefile= s:NetrwHome()."/.netrwbook" |
| 3616 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3617 | if filereadable(s:NetrwFile(savefile)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3618 | let booklist= deepcopy(g:netrw_bookmarklist) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3619 | exe "sil NetrwKeepj keepalt so ".savefile |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3620 | for bdm in booklist |
| 3621 | if index(g:netrw_bookmarklist,bdm) == -1 |
| 3622 | call add(g:netrw_bookmarklist,bdm) |
| 3623 | endif |
| 3624 | endfor |
| 3625 | call sort(g:netrw_bookmarklist) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3626 | endif |
| 3627 | |
| 3628 | " construct and save .netrwbook |
| 3629 | call setline(1,"let g:netrw_bookmarklist= ".string(g:netrw_bookmarklist)) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 3630 | exe "sil! w! ".savefile |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3631 | endif |
| 3632 | let bgone= bufnr("%") |
| 3633 | q! |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3634 | exe "keepalt ".bgone."bwipe!" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3635 | |
| 3636 | " call Dret("s:NetrwBookHistSave") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 3637 | endfun |
| 3638 | |
| 3639 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3640 | " s:NetrwBrowse: This function uses the command in g:netrw_list_cmd to provide a {{{2 |
| 3641 | " list of the contents of a local or remote directory. It is assumed that the |
| 3642 | " g:netrw_list_cmd has a string, USEPORT HOSTNAME, that needs to be substituted |
| 3643 | " with the requested remote hostname first. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3644 | " Often called via: Explore/e dirname/etc -> netrw#LocalBrowseCheck() -> s:NetrwBrowse() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3645 | fun! s:NetrwBrowse(islocal,dirname) |
| 3646 | if !exists("w:netrw_liststyle")|let w:netrw_liststyle= g:netrw_liststyle|endif |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 3647 | " call Dfunc("s:NetrwBrowse(islocal=".a:islocal." dirname<".a:dirname.">) liststyle=".w:netrw_liststyle." ".g:loaded_netrw." buf#".bufnr("%")."<".bufname("%")."> win#".winnr()) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3648 | " call Decho("modified=".&modified." modifiable=".&modifiable." readonly=".&readonly,'~'.expand("<slnum>")) |
| 3649 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3650 | " call Dredir("ls!","s:NetrwBrowse") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3651 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3652 | " save alternate-file's filename if w:netrw_rexlocal doesn't exist |
| 3653 | " This is useful when one edits a local file, then :e ., then :Rex |
| 3654 | if a:islocal && !exists("w:netrw_rexfile") && bufname("#") != "" |
| 3655 | let w:netrw_rexfile= bufname("#") |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3656 | " call Decho("setting w:netrw_rexfile<".w:netrw_rexfile."> win#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3657 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3658 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3659 | " s:NetrwBrowse : initialize history {{{3 |
| 3660 | if !exists("s:netrw_initbookhist") |
| 3661 | NetrwKeepj call s:NetrwBookHistRead() |
| 3662 | endif |
| 3663 | |
| 3664 | " s:NetrwBrowse : simplify the dirname (especially for ".."s in dirnames) {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3665 | if a:dirname !~ '^\a\{3,}://' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3666 | let dirname= simplify(a:dirname) |
| 3667 | else |
| 3668 | let dirname= a:dirname |
| 3669 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3670 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3671 | " repoint t:netrw_lexbufnr if appropriate |
| 3672 | if exists("t:netrw_lexbufnr") && bufnr("%") == t:netrw_lexbufnr |
| 3673 | " call Decho("set repointlexbufnr to true!") |
| 3674 | let repointlexbufnr= 1 |
| 3675 | endif |
| 3676 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3677 | if exists("s:netrw_skipbrowse") |
| 3678 | unlet s:netrw_skipbrowse |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3679 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." filename<".expand("%")."> win#".winnr()." ft<".&ft.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3680 | " call Dret("s:NetrwBrowse : s:netrw_skipbrowse existed") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3681 | return |
| 3682 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3683 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3684 | " s:NetrwBrowse : sanity checks: {{{3 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3685 | if !exists("*shellescape") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3686 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"netrw can't run -- your vim is missing shellescape()",69) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3687 | " call Dret("s:NetrwBrowse : missing shellescape()") |
| 3688 | return |
| 3689 | endif |
| 3690 | if !exists("*fnameescape") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3691 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"netrw can't run -- your vim is missing fnameescape()",70) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3692 | " call Dret("s:NetrwBrowse : missing fnameescape()") |
| 3693 | return |
| 3694 | endif |
| 3695 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3696 | " s:NetrwBrowse : save options: {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3697 | call s:NetrwOptionSave("w:") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3698 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3699 | " s:NetrwBrowse : re-instate any marked files {{{3 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3700 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 3701 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
| 3702 | " call Decho("clearing marked files",'~'.expand("<slnum>")) |
| 3703 | exe "2match netrwMarkFile /".s:netrwmarkfilemtch_{bufnr("%")}."/" |
| 3704 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3705 | endif |
| 3706 | |
| 3707 | if a:islocal && exists("w:netrw_acdkeep") && w:netrw_acdkeep |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3708 | " s:NetrwBrowse : set up "safe" options for local directory/file {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3709 | " call Decho("handle w:netrw_acdkeep:",'~'.expand("<slnum>")) |
| 3710 | " call Decho("NetrwKeepj lcd ".fnameescape(dirname)." (due to w:netrw_acdkeep=".w:netrw_acdkeep." - acd=".&acd.")",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3711 | if s:NetrwLcd(dirname) |
| 3712 | " call Dret("s:NetrwBrowse : lcd failure") |
| 3713 | return |
| 3714 | endif |
| 3715 | " call s:NetrwSafeOptions() " tst953 failed with this enabled. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3716 | " call Decho("getcwd<".getcwd().">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3717 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3718 | elseif !a:islocal && dirname !~ '[\/]$' && dirname !~ '^"' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3719 | " s:NetrwBrowse : remote regular file handler {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3720 | " call Decho("handle remote regular file: dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3721 | if bufname(dirname) != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3722 | " call Decho("edit buf#".bufname(dirname)." in win#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3723 | exe "NetrwKeepj b ".bufname(dirname) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3724 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3725 | " attempt transfer of remote regular file |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3726 | " call Decho("attempt transfer as regular file<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3727 | |
| 3728 | " remove any filetype indicator from end of dirname, except for the |
| 3729 | " "this is a directory" indicator (/). |
| 3730 | " There shouldn't be one of those here, anyway. |
| 3731 | let path= substitute(dirname,'[*=@|]\r\=$','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3732 | " call Decho("new path<".path.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3733 | call s:RemotePathAnalysis(dirname) |
| 3734 | |
| 3735 | " s:NetrwBrowse : remote-read the requested file into current buffer {{{3 |
| 3736 | call s:NetrwEnew(dirname) |
| 3737 | call s:NetrwSafeOptions() |
| 3738 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3739 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3740 | let b:netrw_curdir = dirname |
| 3741 | let url = s:method."://".((s:user == "")? "" : s:user."@").s:machine.(s:port ? ":".s:port : "")."/".s:path |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3742 | call s:NetrwBufRename(url) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3743 | exe "sil! NetrwKeepj keepalt doau BufReadPre ".fnameescape(s:fname) |
| 3744 | sil call netrw#NetRead(2,url) |
| 3745 | " netrw.vim and tar.vim have already handled decompression of the tarball; avoiding gzip.vim error |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3746 | " call Decho("url<".url.">",'~'.expand("<slnum>")) |
| 3747 | " call Decho("s:path<".s:path.">",'~'.expand("<slnum>")) |
| 3748 | " call Decho("s:fname<".s:fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3749 | if s:path =~ '.bz2' |
| 3750 | exe "sil NetrwKeepj keepalt doau BufReadPost ".fnameescape(substitute(s:fname,'\.bz2$','','')) |
| 3751 | elseif s:path =~ '.gz' |
| 3752 | exe "sil NetrwKeepj keepalt doau BufReadPost ".fnameescape(substitute(s:fname,'\.gz$','','')) |
| 3753 | elseif s:path =~ '.gz' |
| 3754 | exe "sil NetrwKeepj keepalt doau BufReadPost ".fnameescape(substitute(s:fname,'\.txz$','','')) |
| 3755 | else |
| 3756 | exe "sil NetrwKeepj keepalt doau BufReadPost ".fnameescape(s:fname) |
| 3757 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3758 | endif |
| 3759 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3760 | " s:NetrwBrowse : save certain window-oriented variables into buffer-oriented variables {{{3 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3761 | call s:SetBufWinVars() |
| 3762 | call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3763 | " call Decho("setl ma nomod",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3764 | setl ma nomod noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3765 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3766 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3767 | " call Dret("s:NetrwBrowse : file<".s:fname.">") |
| 3768 | return |
| 3769 | endif |
| 3770 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3771 | " use buffer-oriented WinVars if buffer variables exist but associated window variables don't {{{3 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3772 | call s:UseBufWinVars() |
| 3773 | |
| 3774 | " set up some variables {{{3 |
| 3775 | let b:netrw_browser_active = 1 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3776 | let dirname = dirname |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3777 | let s:last_sort_by = g:netrw_sort_by |
| 3778 | |
| 3779 | " set up menu {{{3 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3780 | NetrwKeepj call s:NetrwMenu(1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3781 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3782 | " get/set-up buffer {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3783 | " call Decho("saving position across a buffer refresh",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3784 | let svpos = winsaveview() |
| 3785 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3786 | let reusing= s:NetrwGetBuffer(a:islocal,dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3787 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3788 | " maintain markfile highlighting |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3789 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 3790 | if exists("s:netrwmarkfilemtch_{bufnr('%')}") && s:netrwmarkfilemtch_{bufnr("%")} != "" |
| 3791 | " " call Decho("bufnr(%)=".bufnr('%'),'~'.expand("<slnum>")) |
| 3792 | " " call Decho("exe 2match netrwMarkFile /".s:netrwmarkfilemtch_{bufnr("%")}."/",'~'.expand("<slnum>")) |
| 3793 | exe "2match netrwMarkFile /".s:netrwmarkfilemtch_{bufnr("%")}."/" |
| 3794 | else |
| 3795 | " " call Decho("2match none",'~'.expand("<slnum>")) |
| 3796 | 2match none |
| 3797 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3798 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 3799 | if reusing && line("$") > 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3800 | call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3801 | " call Decho("setl noma nomod nowrap",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3802 | setl noma nomod nowrap |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3803 | " call Decho("(set noma nomod nowrap) ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3804 | " call Dret("s:NetrwBrowse : re-using not-cleared buffer") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3805 | return |
| 3806 | endif |
| 3807 | |
| 3808 | " set b:netrw_curdir to the new directory name {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3809 | " call Decho("set b:netrw_curdir to the new directory name<".dirname."> (buf#".bufnr("%").")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 3810 | let b:netrw_curdir= dirname |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3811 | if b:netrw_curdir =~ '[/\\]$' |
| 3812 | let b:netrw_curdir= substitute(b:netrw_curdir,'[/\\]$','','e') |
| 3813 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 3814 | if b:netrw_curdir =~ '\a:$' && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 3815 | let b:netrw_curdir= b:netrw_curdir."/" |
| 3816 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3817 | if b:netrw_curdir == '' |
| 3818 | if has("amiga") |
| 3819 | " On the Amiga, the empty string connotes the current directory |
| 3820 | let b:netrw_curdir= getcwd() |
| 3821 | else |
| 3822 | " under unix, when the root directory is encountered, the result |
| 3823 | " from the preceding substitute is an empty string. |
| 3824 | let b:netrw_curdir= '/' |
| 3825 | endif |
| 3826 | endif |
| 3827 | if !a:islocal && b:netrw_curdir !~ '/$' |
| 3828 | let b:netrw_curdir= b:netrw_curdir.'/' |
| 3829 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3830 | " call Decho("b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3831 | |
| 3832 | " ------------ |
| 3833 | " (local only) {{{3 |
| 3834 | " ------------ |
| 3835 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3836 | " call Decho("local only:",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3837 | |
| 3838 | " Set up ShellCmdPost handling. Append current buffer to browselist |
| 3839 | call s:LocalFastBrowser() |
| 3840 | |
| 3841 | " handle g:netrw_keepdir: set vim's current directory to netrw's notion of the current directory {{{3 |
| 3842 | if !g:netrw_keepdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3843 | " call Decho("handle g:netrw_keepdir=".g:netrw_keepdir.": getcwd<".getcwd()."> acd=".&acd,'~'.expand("<slnum>")) |
| 3844 | " call Decho("l:acd".(exists("&l:acd")? "=".&l:acd : " doesn't exist"),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3845 | if !exists("&l:acd") || !&l:acd |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3846 | if s:NetrwLcd(b:netrw_curdir) |
| 3847 | " call Dret("s:NetrwBrowse : lcd failure") |
| 3848 | return |
| 3849 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3850 | endif |
| 3851 | endif |
| 3852 | |
| 3853 | " -------------------------------- |
| 3854 | " remote handling: {{{3 |
| 3855 | " -------------------------------- |
| 3856 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3857 | " call Decho("remote only:",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3858 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 3859 | " analyze dirname and g:netrw_list_cmd {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3860 | " call Decho("b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : "doesn't exist")."> dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3861 | if dirname =~# "^NetrwTreeListing\>" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3862 | let dirname= b:netrw_curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3863 | " call Decho("(dirname was <NetrwTreeListing>) dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3864 | elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("b:netrw_curdir") |
| 3865 | let dirname= substitute(b:netrw_curdir,'\\','/','g') |
| 3866 | if dirname !~ '/$' |
| 3867 | let dirname= dirname.'/' |
| 3868 | endif |
| 3869 | let b:netrw_curdir = dirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3870 | " call Decho("(liststyle is TREELIST) dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3871 | else |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3872 | let dirname = substitute(dirname,'\\','/','g') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3873 | " call Decho("(normal) dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3874 | endif |
| 3875 | |
| 3876 | let dirpat = '^\(\w\{-}\)://\(\w\+@\)\=\([^/]\+\)/\(.*\)$' |
| 3877 | if dirname !~ dirpat |
| 3878 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3879 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"netrw doesn't understand your dirname<".dirname.">",20) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3880 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3881 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3882 | " call Decho("setl noma nomod nowrap",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 3883 | setl noma nomod nowrap |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3884 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3885 | " call Dret("s:NetrwBrowse : badly formatted dirname<".dirname.">") |
| 3886 | return |
| 3887 | endif |
| 3888 | let b:netrw_curdir= dirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3889 | " call Decho("b:netrw_curdir<".b:netrw_curdir."> (remote)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3890 | endif " (additional remote handling) |
| 3891 | |
| 3892 | " ----------------------- |
| 3893 | " Directory Listing: {{{3 |
| 3894 | " ----------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3895 | NetrwKeepj call s:NetrwMaps(a:islocal) |
| 3896 | NetrwKeepj call s:NetrwCommands(a:islocal) |
| 3897 | NetrwKeepj call s:PerformListing(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3898 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3899 | " restore option(s) |
| 3900 | call s:NetrwOptionRestore("w:") |
| 3901 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 3902 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3903 | " If there is a rexposn: restore position with rexposn |
| 3904 | " Otherwise : set rexposn |
| 3905 | if exists("s:rexposn_".bufnr("%")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3906 | " call Decho("restoring posn to s:rexposn_".bufnr('%')."<".string(s:rexposn_{bufnr('%')}).">",'~'.expand("<slnum>")) |
| 3907 | NetrwKeepj call winrestview(s:rexposn_{bufnr('%')}) |
| 3908 | if exists("w:netrw_bannercnt") && line(".") < w:netrw_bannercnt |
| 3909 | NetrwKeepj exe w:netrw_bannercnt |
| 3910 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3911 | else |
| 3912 | NetrwKeepj call s:SetRexDir(a:islocal,b:netrw_curdir) |
| 3913 | endif |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 3914 | if v:version >= 700 && has("balloon_eval") && &beval == 0 && &l:bexpr == "" && !exists("g:netrw_nobeval") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3915 | let &l:bexpr= "netrw#BalloonHelp()" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3916 | " call Decho("set up balloon help: l:bexpr=".&l:bexpr,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3917 | setl beval |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3918 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3919 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 3920 | " repoint t:netrw_lexbufnr if appropriate |
| 3921 | if exists("repointlexbufnr") |
| 3922 | let t:netrw_lexbufnr= bufnr("%") |
| 3923 | " call Decho("repoint t:netrw_lexbufnr to #".t:netrw_lexbufnr) |
| 3924 | endif |
| 3925 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3926 | " restore position |
| 3927 | if reusing |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3928 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 3929 | call winrestview(svpos) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 3930 | endif |
| 3931 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3932 | " The s:LocalBrowseRefresh() function is called by an autocmd |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 3933 | " installed by s:LocalFastBrowser() when g:netrw_fastbrowse <= 1 (ie. slow, medium speed). |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 3934 | " However, s:NetrwBrowse() causes the FocusGained event to fire the firstt time. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3935 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 3936 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 3937 | " call Dret("s:NetrwBrowse : did PerformListing ft<".&ft.">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 3938 | return |
| 3939 | endfun |
| 3940 | |
| 3941 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3942 | " s:NetrwFile: because of g:netrw_keepdir, isdirectory(), type(), etc may or {{{2 |
| 3943 | " may not apply correctly; ie. netrw's idea of the current directory may |
| 3944 | " differ from vim's. This function insures that netrw's idea of the current |
| 3945 | " directory is used. |
| 3946 | fun! s:NetrwFile(fname) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3947 | " call Dfunc("s:NetrwFile(fname<".a:fname.">) win#".winnr()) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3948 | " call Decho("g:netrw_keepdir =".(exists("g:netrw_keepdir")? g:netrw_keepdir : 'n/a'),'~'.expand("<slnum>")) |
| 3949 | " call Decho("g:netrw_cygwin =".(exists("g:netrw_cygwin")? g:netrw_cygwin : 'n/a'),'~'.expand("<slnum>")) |
| 3950 | " call Decho("g:netrw_liststyle=".(exists("g:netrw_liststyle")? g:netrw_liststyle : 'n/a'),'~'.expand("<slnum>")) |
| 3951 | " call Decho("w:netrw_liststyle=".(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3952 | |
| 3953 | " clean up any leading treedepthstring |
| 3954 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
| 3955 | let fname= substitute(a:fname,'^'.s:treedepthstring.'\+','','') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3956 | " call Decho("clean up any leading treedepthstring: fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3957 | else |
| 3958 | let fname= a:fname |
| 3959 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3960 | |
| 3961 | if g:netrw_keepdir |
| 3962 | " vim's idea of the current directory possibly may differ from netrw's |
| 3963 | if !exists("b:netrw_curdir") |
| 3964 | let b:netrw_curdir= getcwd() |
| 3965 | endif |
| 3966 | |
| 3967 | if !exists("g:netrw_cygwin") && (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3968 | if fname =~ '^\' || fname =~ '^\a:\' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3969 | " windows, but full path given |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3970 | let ret= fname |
| 3971 | " call Decho("windows+full path: isdirectory(".fname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3972 | else |
| 3973 | " windows, relative path given |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3974 | let ret= s:ComposePath(b:netrw_curdir,fname) |
| 3975 | " call Decho("windows+rltv path: isdirectory(".fname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3976 | endif |
| 3977 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3978 | elseif fname =~ '^/' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3979 | " not windows, full path given |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3980 | let ret= fname |
| 3981 | " call Decho("unix+full path: isdirectory(".fname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3982 | else |
| 3983 | " not windows, relative path given |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3984 | let ret= s:ComposePath(b:netrw_curdir,fname) |
| 3985 | " call Decho("unix+rltv path: isdirectory(".fname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3986 | endif |
| 3987 | else |
| 3988 | " vim and netrw agree on the current directory |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 3989 | let ret= fname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3990 | " call Decho("vim and netrw agree on current directory (g:netrw_keepdir=".g:netrw_keepdir.")",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 3991 | " call Decho("vim directory: ".getcwd(),'~'.expand("<slnum>")) |
| 3992 | " call Decho("netrw directory: ".(exists("b:netrw_curdir")? b:netrw_curdir : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 3993 | endif |
| 3994 | |
| 3995 | " call Dret("s:NetrwFile ".ret) |
| 3996 | return ret |
| 3997 | endfun |
| 3998 | |
| 3999 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4000 | " s:NetrwFileInfo: supports qf (query for file information) {{{2 |
| 4001 | fun! s:NetrwFileInfo(islocal,fname) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4002 | " call Dfunc("s:NetrwFileInfo(islocal=".a:islocal." fname<".a:fname.">) b:netrw_curdir<".b:netrw_curdir.">") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4003 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4004 | if a:islocal |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4005 | let lsopt= "-lsad" |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4006 | if g:netrw_sizestyle =~# 'H' |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4007 | let lsopt= "-lsadh" |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4008 | elseif g:netrw_sizestyle =~# 'h' |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4009 | let lsopt= "-lsadh --si" |
| 4010 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4011 | if (has("unix") || has("macunix")) && executable("/bin/ls") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4012 | |
| 4013 | if getline(".") == "../" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4014 | echo system("/bin/ls ".lsopt." ".s:ShellEscape("..")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4015 | " call Decho("#1: echo system(/bin/ls -lsad ".s:ShellEscape(..).")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4016 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4017 | elseif w:netrw_liststyle == s:TREELIST && getline(".") !~ '^'.s:treedepthstring |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4018 | echo system("/bin/ls ".lsopt." ".s:ShellEscape(b:netrw_curdir)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4019 | " call Decho("#2: echo system(/bin/ls -lsad ".s:ShellEscape(b:netrw_curdir).")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4020 | |
| 4021 | elseif exists("b:netrw_curdir") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4022 | echo system("/bin/ls ".lsopt." ".s:ShellEscape(s:ComposePath(b:netrw_curdir,a:fname))) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4023 | " call Decho("#3: echo system(/bin/ls -lsad ".s:ShellEscape(b:netrw_curdir.a:fname).")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4024 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4025 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4026 | " call Decho('using ls '.a:fname." using cwd<".getcwd().">",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4027 | echo system("/bin/ls ".lsopt." ".s:ShellEscape(s:NetrwFile(a:fname))) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4028 | " call Decho("#5: echo system(/bin/ls -lsad ".s:ShellEscape(a:fname).")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4029 | endif |
| 4030 | else |
| 4031 | " use vim functions to return information about file below cursor |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4032 | " call Decho("using vim functions to query for file info",'~'.expand("<slnum>")) |
| 4033 | if !isdirectory(s:NetrwFile(a:fname)) && !filereadable(s:NetrwFile(a:fname)) && a:fname =~ '[*@/]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4034 | let fname= substitute(a:fname,".$","","") |
| 4035 | else |
| 4036 | let fname= a:fname |
| 4037 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4038 | let t = getftime(s:NetrwFile(fname)) |
| 4039 | let sz = getfsize(s:NetrwFile(fname)) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4040 | if g:netrw_sizestyle =~# "[hH]" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4041 | let sz= s:NetrwHumanReadable(sz) |
| 4042 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4043 | echo a:fname.": ".sz." ".strftime(g:netrw_timefmt,getftime(s:NetrwFile(fname))) |
| 4044 | " call Decho("fname.": ".sz." ".strftime(g:netrw_timefmt,getftime(fname)),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4045 | endif |
| 4046 | else |
| 4047 | echo "sorry, \"qf\" not supported yet for remote files" |
| 4048 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4049 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4050 | " call Dret("s:NetrwFileInfo") |
| 4051 | endfun |
| 4052 | |
| 4053 | " --------------------------------------------------------------------- |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4054 | " s:NetrwFullPath: returns the full path to a directory and/or file {{{2 |
| 4055 | fun! s:NetrwFullPath(filename) |
| 4056 | " " call Dfunc("s:NetrwFullPath(filename<".a:filename.">)") |
| 4057 | let filename= a:filename |
| 4058 | if filename !~ '^/' |
| 4059 | let filename= resolve(getcwd().'/'.filename) |
| 4060 | endif |
| 4061 | if filename != "/" && filename =~ '/$' |
| 4062 | let filename= substitute(filename,'/$','','') |
| 4063 | endif |
| 4064 | " " call Dret("s:NetrwFullPath <".filename.">") |
| 4065 | return filename |
| 4066 | endfun |
| 4067 | |
| 4068 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4069 | " s:NetrwGetBuffer: [get a new|find an old netrw] buffer for a netrw listing {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4070 | " returns 0=cleared buffer |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4071 | " 1=re-used buffer (buffer not cleared) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4072 | fun! s:NetrwGetBuffer(islocal,dirname) |
| 4073 | " call Dfunc("s:NetrwGetBuffer(islocal=".a:islocal." dirname<".a:dirname.">) liststyle=".g:netrw_liststyle) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4074 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4075 | " call Decho("netrwbuf dictionary=".(exists("s:netrwbuf")? string(s:netrwbuf) : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4076 | let dirname= a:dirname |
| 4077 | |
| 4078 | " re-use buffer if possible {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4079 | " call Decho("--re-use a buffer if possible--",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4080 | if !exists("s:netrwbuf") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4081 | " call Decho(" s:netrwbuf initialized to {}",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4082 | let s:netrwbuf= {} |
| 4083 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4084 | " call Decho(" s:netrwbuf =".string(s:netrwbuf),'~'.expand("<slnum>")) |
| 4085 | " call Decho(" w:netrw_liststyle =".(exists("w:netrw_liststyle")? w:netrw_liststyle : "n/a"),'~'.expand("<slnum>")) |
| 4086 | |
| 4087 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
| 4088 | let bufnum = -1 |
| 4089 | |
| 4090 | if !empty(s:netrwbuf) && has_key(s:netrwbuf,s:NetrwFullPath(dirname)) |
| 4091 | if has_key(s:netrwbuf,"NetrwTreeListing") |
| 4092 | let bufnum= s:netrwbuf["NetrwTreeListing"] |
| 4093 | else |
| 4094 | let bufnum= s:netrwbuf[s:NetrwFullPath(dirname)] |
| 4095 | endif |
| 4096 | " call Decho(" NetrwTreeListing: bufnum#".bufnum,'~'.expand("<slnum>")) |
| 4097 | if !bufexists(bufnum) |
| 4098 | call remove(s:netrwbuf,"NetrwTreeListing"]) |
| 4099 | let bufnum= -1 |
| 4100 | endif |
| 4101 | elseif bufnr("NetrwTreeListing") != -1 |
| 4102 | let bufnum= bufnr("NetrwTreeListing") |
| 4103 | " call Decho(" NetrwTreeListing".": bufnum#".bufnum,'~'.expand("<slnum>")) |
| 4104 | else |
| 4105 | " call Decho(" did not find a NetrwTreeListing buffer",'~'.expand("<slnum>")) |
| 4106 | let bufnum= -1 |
| 4107 | endif |
| 4108 | |
| 4109 | elseif has_key(s:netrwbuf,s:NetrwFullPath(dirname)) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4110 | let bufnum= s:netrwbuf[s:NetrwFullPath(dirname)] |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4111 | " call Decho(" lookup netrwbuf dictionary: s:netrwbuf[".s:NetrwFullPath(dirname)."]=".bufnum,'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4112 | if !bufexists(bufnum) |
| 4113 | call remove(s:netrwbuf,s:NetrwFullPath(dirname)) |
| 4114 | let bufnum= -1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4115 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4116 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4117 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4118 | " call Decho(" lookup netrwbuf dictionary: s:netrwbuf[".s:NetrwFullPath(dirname)."] not a key",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4119 | let bufnum= -1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4120 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4121 | " call Decho(" bufnum#".bufnum,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4122 | |
| 4123 | " get enew buffer and name it -or- re-use buffer {{{3 |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4124 | if bufnum < 0 " get enew buffer and name it |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4125 | " call Decho("--get enew buffer and name it (bufnum#".bufnum."<0 OR bufexists(".bufnum.")=".bufexists(bufnum)."==0)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4126 | call s:NetrwEnew(dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4127 | " call Decho(" got enew buffer#".bufnr("%")." (altbuf<".expand("#").">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4128 | " name the buffer |
| 4129 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
| 4130 | " Got enew buffer; transform into a NetrwTreeListing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4131 | " call Decho("--transform enew buffer#".bufnr("%")." into a NetrwTreeListing --",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4132 | let w:netrw_treebufnr = bufnr("%") |
| 4133 | call s:NetrwBufRename("NetrwTreeListing") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4134 | if g:netrw_use_noswf |
| 4135 | setl nobl bt=nofile noswf |
| 4136 | else |
| 4137 | setl nobl bt=nofile |
| 4138 | endif |
| 4139 | nnoremap <silent> <buffer> [[ :sil call <SID>TreeListMove('[[')<cr> |
| 4140 | nnoremap <silent> <buffer> ]] :sil call <SID>TreeListMove(']]')<cr> |
| 4141 | nnoremap <silent> <buffer> [] :sil call <SID>TreeListMove('[]')<cr> |
| 4142 | nnoremap <silent> <buffer> ][ :sil call <SID>TreeListMove('][')<cr> |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4143 | " call Decho(" tree listing bufnr=".w:netrw_treebufnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4144 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4145 | call s:NetrwBufRename(dirname) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4146 | " enter the new buffer into the s:netrwbuf dictionary |
| 4147 | let s:netrwbuf[s:NetrwFullPath(dirname)]= bufnr("%") |
| 4148 | " call Decho("update netrwbuf dictionary: s:netrwbuf[".s:NetrwFullPath(dirname)."]=".bufnr("%"),'~'.expand("<slnum>")) |
| 4149 | " call Decho("netrwbuf dictionary=".string(s:netrwbuf),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4150 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4151 | " call Decho(" named enew buffer#".bufnr("%")."<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4152 | |
| 4153 | else " Re-use the buffer |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4154 | " call Decho("--re-use buffer#".bufnum." (bufnum#".bufnum.">=0 AND bufexists(".bufnum.")=".bufexists(bufnum)."!=0)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4155 | let eikeep= &ei |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4156 | setl ei=all |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4157 | if getline(2) =~# '^" Netrw Directory Listing' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4158 | " call Decho(" getline(2)<".getline(2).'> matches "Netrw Directory Listing" : using keepalt b '.bufnum,'~'.expand("<slnum>")) |
| 4159 | exe "sil! NetrwKeepj noswapfile keepalt b ".bufnum |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4160 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4161 | " call Decho(" getline(2)<".getline(2).'> does not match "Netrw Directory Listing" : using b '.bufnum,'~'.expand("<slnum>")) |
| 4162 | exe "sil! NetrwKeepj noswapfile keepalt b ".bufnum |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4163 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4164 | " call Decho(" line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4165 | if bufname("%") == '.' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4166 | call s:NetrwBufRename(getcwd()) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4167 | endif |
| 4168 | let &ei= eikeep |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4169 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4170 | if line("$") <= 1 && getline(1) == "" |
| 4171 | " empty buffer |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4172 | NetrwKeepj call s:NetrwListSettings(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4173 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 4174 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4175 | " call Dret("s:NetrwGetBuffer 0<buffer empty> : re-using buffer#".bufnr("%").", but its empty, so refresh it") |
| 4176 | return 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4177 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4178 | elseif g:netrw_fastbrowse == 0 || (a:islocal && g:netrw_fastbrowse == 1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4179 | " call Decho("g:netrw_fastbrowse=".g:netrw_fastbrowse." a:islocal=".a:islocal.": clear buffer",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4180 | NetrwKeepj call s:NetrwListSettings(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4181 | sil NetrwKeepj %d _ |
| 4182 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 4183 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4184 | " call Dret("s:NetrwGetBuffer 0<cleared buffer> : re-using buffer#".bufnr("%").", but refreshing due to g:netrw_fastbrowse=".g:netrw_fastbrowse) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4185 | return 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4186 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4187 | elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4188 | " call Decho("--re-use tree listing--",'~'.expand("<slnum>")) |
| 4189 | " call Decho(" clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4190 | setl ma |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4191 | sil NetrwKeepj %d _ |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4192 | NetrwKeepj call s:NetrwListSettings(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4193 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 4194 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4195 | " call Dret("s:NetrwGetBuffer 0<cleared buffer> : re-using buffer#".bufnr("%").", but treelist mode always needs a refresh") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4196 | return 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4197 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4198 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4199 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 4200 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 4201 | " call Dret("s:NetrwGetBuffer 1<buffer not cleared>") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4202 | return 1 |
| 4203 | endif |
| 4204 | endif |
| 4205 | |
| 4206 | " do netrw settings: make this buffer not-a-file, modifiable, not line-numbered, etc {{{3 |
| 4207 | " fastbrowse Local Remote Hiding a buffer implies it may be re-used (fast) |
| 4208 | " slow 0 D D Deleting a buffer implies it will not be re-used (slow) |
| 4209 | " med 1 D H |
| 4210 | " fast 2 H H |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4211 | " call Decho("--do netrw settings: make this buffer#".bufnr("%")." not-a-file, modifiable, not line-numbered, etc--",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4212 | let fname= expand("%") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4213 | NetrwKeepj call s:NetrwListSettings(a:islocal) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4214 | call s:NetrwBufRename(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4215 | |
| 4216 | " delete all lines from buffer {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4217 | " call Decho("--delete all lines from buffer--",'~'.expand("<slnum>")) |
| 4218 | " call Decho(" clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
| 4219 | sil! keepalt NetrwKeepj %d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4220 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4221 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 4222 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 4223 | " call Dret("s:NetrwGetBuffer 0<cleared buffer>") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4224 | return 0 |
| 4225 | endfun |
| 4226 | |
| 4227 | " --------------------------------------------------------------------- |
| 4228 | " s:NetrwGetcwd: get the current directory. {{{2 |
| 4229 | " Change backslashes to forward slashes, if any. |
| 4230 | " If doesc is true, escape certain troublesome characters |
| 4231 | fun! s:NetrwGetcwd(doesc) |
| 4232 | " call Dfunc("NetrwGetcwd(doesc=".a:doesc.")") |
| 4233 | let curdir= substitute(getcwd(),'\\','/','ge') |
| 4234 | if curdir !~ '[\/]$' |
| 4235 | let curdir= curdir.'/' |
| 4236 | endif |
| 4237 | if a:doesc |
| 4238 | let curdir= fnameescape(curdir) |
| 4239 | endif |
| 4240 | " call Dret("NetrwGetcwd <".curdir.">") |
| 4241 | return curdir |
| 4242 | endfun |
| 4243 | |
| 4244 | " --------------------------------------------------------------------- |
| 4245 | " s:NetrwGetWord: it gets the directory/file named under the cursor {{{2 |
| 4246 | fun! s:NetrwGetWord() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4247 | " call Dfunc("s:NetrwGetWord() liststyle=".s:ShowStyle()." virtcol=".virtcol(".")) |
| 4248 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 4249 | let keepsol= &l:sol |
| 4250 | setl nosol |
| 4251 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4252 | call s:UseBufWinVars() |
| 4253 | |
| 4254 | " insure that w:netrw_liststyle is set up |
| 4255 | if !exists("w:netrw_liststyle") |
| 4256 | if exists("g:netrw_liststyle") |
| 4257 | let w:netrw_liststyle= g:netrw_liststyle |
| 4258 | else |
| 4259 | let w:netrw_liststyle= s:THINLIST |
| 4260 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4261 | " call Decho("w:netrw_liststyle=".w:netrw_liststyle,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4262 | endif |
| 4263 | |
| 4264 | if exists("w:netrw_bannercnt") && line(".") < w:netrw_bannercnt |
| 4265 | " Active Banner support |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4266 | " call Decho("active banner handling",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4267 | NetrwKeepj norm! 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4268 | let dirname= "./" |
| 4269 | let curline= getline('.') |
| 4270 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4271 | if curline =~# '"\s*Sorted by\s' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4272 | NetrwKeepj norm s |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4273 | let s:netrw_skipbrowse= 1 |
| 4274 | echo 'Pressing "s" also works' |
| 4275 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4276 | elseif curline =~# '"\s*Sort sequence:' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4277 | let s:netrw_skipbrowse= 1 |
| 4278 | echo 'Press "S" to edit sorting sequence' |
| 4279 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4280 | elseif curline =~# '"\s*Quick Help:' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4281 | NetrwKeepj norm ? |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4282 | let s:netrw_skipbrowse= 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4283 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4284 | elseif curline =~# '"\s*\%(Hiding\|Showing\):' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4285 | NetrwKeepj norm a |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4286 | let s:netrw_skipbrowse= 1 |
| 4287 | echo 'Pressing "a" also works' |
| 4288 | |
| 4289 | elseif line("$") > w:netrw_bannercnt |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4290 | exe 'sil NetrwKeepj '.w:netrw_bannercnt |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4291 | endif |
| 4292 | |
| 4293 | elseif w:netrw_liststyle == s:THINLIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4294 | " call Decho("thin column handling",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4295 | NetrwKeepj norm! 0 |
| 4296 | let dirname= substitute(getline('.'),'\t -->.*$','','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4297 | |
| 4298 | elseif w:netrw_liststyle == s:LONGLIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4299 | " call Decho("long column handling",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4300 | NetrwKeepj norm! 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4301 | let dirname= substitute(getline('.'),'^\(\%(\S\+ \)*\S\+\).\{-}$','\1','e') |
| 4302 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4303 | elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4304 | " call Decho("treelist handling",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4305 | let dirname= substitute(getline('.'),'^\('.s:treedepthstring.'\)*','','e') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4306 | let dirname= substitute(dirname,'\t -->.*$','','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4307 | |
| 4308 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4309 | " call Decho("obtain word from wide listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4310 | let dirname= getline('.') |
| 4311 | |
| 4312 | if !exists("b:netrw_cpf") |
| 4313 | let b:netrw_cpf= 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4314 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$g/^./if virtcol("$") > b:netrw_cpf|let b:netrw_cpf= virtcol("$")|endif' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4315 | call histdel("/",-1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4316 | " "call Decho("computed cpf=".b:netrw_cpf,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4317 | endif |
| 4318 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4319 | " call Decho("buf#".bufnr("%")."<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4320 | let filestart = (virtcol(".")/b:netrw_cpf)*b:netrw_cpf |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4321 | " call Decho("filestart= ([virtcol=".virtcol(".")."]/[b:netrw_cpf=".b:netrw_cpf."])*b:netrw_cpf=".filestart." bannercnt=".w:netrw_bannercnt,'~'.expand("<slnum>")) |
| 4322 | " call Decho("1: dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4323 | if filestart == 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4324 | NetrwKeepj norm! 0ma |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4325 | else |
| 4326 | call cursor(line("."),filestart+1) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4327 | NetrwKeepj norm! ma |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4328 | endif |
| 4329 | let rega= @a |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 4330 | let eofname= filestart + b:netrw_cpf + 1 |
| 4331 | if eofname <= col("$") |
| 4332 | call cursor(line("."),filestart+b:netrw_cpf+1) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4333 | NetrwKeepj norm! "ay`a |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 4334 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4335 | NetrwKeepj norm! "ay$ |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 4336 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4337 | let dirname = @a |
| 4338 | let @a = rega |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4339 | " call Decho("2: dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4340 | let dirname= substitute(dirname,'\s\+$','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4341 | " call Decho("3: dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4342 | endif |
| 4343 | |
| 4344 | " symlinks are indicated by a trailing "@". Remove it before further processing. |
| 4345 | let dirname= substitute(dirname,"@$","","") |
| 4346 | |
| 4347 | " executables are indicated by a trailing "*". Remove it before further processing. |
| 4348 | let dirname= substitute(dirname,"\*$","","") |
| 4349 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4350 | let &l:sol= keepsol |
| 4351 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4352 | " call Dret("s:NetrwGetWord <".dirname.">") |
| 4353 | return dirname |
| 4354 | endfun |
| 4355 | |
| 4356 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4357 | " s:NetrwListSettings: make standard settings for making a netrw listing {{{2 |
| 4358 | " g:netrw_bufsettings will be used after the listing is produced. |
| 4359 | " Called by s:NetrwGetBuffer() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4360 | fun! s:NetrwListSettings(islocal) |
| 4361 | " call Dfunc("s:NetrwListSettings(islocal=".a:islocal.")") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4362 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4363 | let fname= bufname("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4364 | " " call Decho("(NetrwListSettings) setl bt=nofile nobl ma nonu nowrap noro nornu",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4365 | " nobl noma nomod nonu noma nowrap ro nornu (std g:netrw_bufsettings) |
| 4366 | setl bt=nofile nobl ma nonu nowrap noro nornu |
| 4367 | call s:NetrwBufRename(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4368 | if g:netrw_use_noswf |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4369 | setl noswf |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4370 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4371 | " call Dredir("ls!","s:NetrwListSettings") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4372 | " call Decho("(NetrwListSettings) exe setl ts=".(g:netrw_maxfilenamelen+1),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4373 | exe "setl ts=".(g:netrw_maxfilenamelen+1) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4374 | setl isk+=.,~,- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4375 | if g:netrw_fastbrowse > a:islocal |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4376 | setl bh=hide |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4377 | else |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4378 | setl bh=delete |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4379 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4380 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4381 | " call Dret("s:NetrwListSettings") |
| 4382 | endfun |
| 4383 | |
| 4384 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4385 | " s:NetrwListStyle: change list style (thin - long - wide - tree) {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4386 | " islocal=0: remote browsing |
| 4387 | " =1: local browsing |
| 4388 | fun! s:NetrwListStyle(islocal) |
| 4389 | " call Dfunc("NetrwListStyle(islocal=".a:islocal.") w:netrw_liststyle=".w:netrw_liststyle) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4390 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4391 | let ykeep = @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4392 | let fname = s:NetrwGetWord() |
| 4393 | if !exists("w:netrw_liststyle")|let w:netrw_liststyle= g:netrw_liststyle|endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4394 | let svpos = winsaveview() |
| 4395 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4396 | let w:netrw_liststyle = (w:netrw_liststyle + 1) % s:MAXLIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4397 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
| 4398 | " call Decho("chgd w:netrw_liststyle to ".w:netrw_liststyle,'~'.expand("<slnum>")) |
| 4399 | " call Decho("b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : "doesn't exist").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4400 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4401 | " repoint t:netrw_lexbufnr if appropriate |
| 4402 | if exists("t:netrw_lexbufnr") && bufnr("%") == t:netrw_lexbufnr |
| 4403 | " call Decho("set repointlexbufnr to true!") |
| 4404 | let repointlexbufnr= 1 |
| 4405 | endif |
| 4406 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4407 | if w:netrw_liststyle == s:THINLIST |
| 4408 | " use one column listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4409 | " call Decho("use one column list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4410 | let g:netrw_list_cmd = substitute(g:netrw_list_cmd,' -l','','ge') |
| 4411 | |
| 4412 | elseif w:netrw_liststyle == s:LONGLIST |
| 4413 | " use long list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4414 | " call Decho("use long list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4415 | let g:netrw_list_cmd = g:netrw_list_cmd." -l" |
| 4416 | |
| 4417 | elseif w:netrw_liststyle == s:WIDELIST |
| 4418 | " give wide list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4419 | " call Decho("use wide list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4420 | let g:netrw_list_cmd = substitute(g:netrw_list_cmd,' -l','','ge') |
| 4421 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4422 | elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4423 | " call Decho("use tree list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4424 | let g:netrw_list_cmd = substitute(g:netrw_list_cmd,' -l','','ge') |
| 4425 | |
| 4426 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4427 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"bad value for g:netrw_liststyle (=".w:netrw_liststyle.")",46) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4428 | let g:netrw_liststyle = s:THINLIST |
| 4429 | let w:netrw_liststyle = g:netrw_liststyle |
| 4430 | let g:netrw_list_cmd = substitute(g:netrw_list_cmd,' -l','','ge') |
| 4431 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4432 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4433 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4434 | |
| 4435 | " clear buffer - this will cause NetrwBrowse/LocalBrowseCheck to do a refresh |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4436 | " call Decho("clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
| 4437 | sil! NetrwKeepj %d _ |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4438 | " following prevents tree listing buffer from being marked "modified" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4439 | " call Decho("setl nomod",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 4440 | setl nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4441 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4442 | |
| 4443 | " refresh the listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4444 | " call Decho("refresh the listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4445 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 4446 | NetrwKeepj call s:NetrwCursor() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4447 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4448 | " repoint t:netrw_lexbufnr if appropriate |
| 4449 | if exists("repointlexbufnr") |
| 4450 | let t:netrw_lexbufnr= bufnr("%") |
| 4451 | " call Decho("repoint t:netrw_lexbufnr to #".t:netrw_lexbufnr) |
| 4452 | endif |
| 4453 | |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4454 | " restore position; keep cursor on the filename |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4455 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 4456 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4457 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4458 | |
| 4459 | " call Dret("NetrwListStyle".(exists("w:netrw_liststyle")? ' : w:netrw_liststyle='.w:netrw_liststyle : "")) |
| 4460 | endfun |
| 4461 | |
| 4462 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4463 | " s:NetrwBannerCtrl: toggles the display of the banner {{{2 |
| 4464 | fun! s:NetrwBannerCtrl(islocal) |
| 4465 | " call Dfunc("s:NetrwBannerCtrl(islocal=".a:islocal.") g:netrw_banner=".g:netrw_banner) |
| 4466 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4467 | let ykeep= @@ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4468 | " toggle the banner (enable/suppress) |
| 4469 | let g:netrw_banner= !g:netrw_banner |
| 4470 | |
| 4471 | " refresh the listing |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4472 | let svpos= winsaveview() |
| 4473 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4474 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 4475 | |
| 4476 | " keep cursor on the filename |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4477 | if g:netrw_banner && exists("w:netrw_bannercnt") && line(".") >= w:netrw_bannercnt |
| 4478 | let fname= s:NetrwGetWord() |
| 4479 | sil NetrwKeepj $ |
| 4480 | let result= search('\%(^\%(|\+\s\)\=\|\s\{2,}\)\zs'.escape(fname,'.\[]*$^').'\%(\s\{2,}\|$\)','bc') |
| 4481 | " " call Decho("search result=".result." w:netrw_bannercnt=".(exists("w:netrw_bannercnt")? w:netrw_bannercnt : 'N/A'),'~'.expand("<slnum>")) |
| 4482 | if result <= 0 && exists("w:netrw_bannercnt") |
| 4483 | exe "NetrwKeepj ".w:netrw_bannercnt |
| 4484 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4485 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4486 | let @@= ykeep |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4487 | " call Dret("s:NetrwBannerCtrl : g:netrw_banner=".g:netrw_banner) |
| 4488 | endfun |
| 4489 | |
| 4490 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4491 | " s:NetrwBookmark: supports :NetrwMB[!] [file]s {{{2 |
| 4492 | " |
| 4493 | " No bang: enters files/directories into Netrw's bookmark system |
| 4494 | " No argument and in netrw buffer: |
| 4495 | " if there are marked files: bookmark marked files |
| 4496 | " otherwise : bookmark file/directory under cursor |
| 4497 | " No argument and not in netrw buffer: bookmarks current open file |
| 4498 | " Has arguments: globs them individually and bookmarks them |
| 4499 | " |
| 4500 | " With bang: deletes files/directories from Netrw's bookmark system |
| 4501 | fun! s:NetrwBookmark(del,...) |
| 4502 | " call Dfunc("s:NetrwBookmark(del=".a:del.",...) a:0=".a:0) |
| 4503 | if a:0 == 0 |
| 4504 | if &ft == "netrw" |
| 4505 | let curbufnr = bufnr("%") |
| 4506 | |
| 4507 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 4508 | " for every filename in the marked list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4509 | " call Decho("bookmark every filename in marked list",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4510 | let svpos = winsaveview() |
| 4511 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4512 | let islocal= expand("%") !~ '^\a\{3,}://' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4513 | for fname in s:netrwmarkfilelist_{curbufnr} |
| 4514 | if a:del|call s:DeleteBookmark(fname)|else|call s:MakeBookmark(fname)|endif |
| 4515 | endfor |
| 4516 | let curdir = exists("b:netrw_curdir")? b:netrw_curdir : getcwd() |
| 4517 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 4518 | NetrwKeepj call s:NetrwRefresh(islocal,s:NetrwBrowseChgDir(islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4519 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 4520 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4521 | else |
| 4522 | let fname= s:NetrwGetWord() |
| 4523 | if a:del|call s:DeleteBookmark(fname)|else|call s:MakeBookmark(fname)|endif |
| 4524 | endif |
| 4525 | |
| 4526 | else |
| 4527 | " bookmark currently open file |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4528 | " call Decho("bookmark currently open file",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4529 | let fname= expand("%") |
| 4530 | if a:del|call s:DeleteBookmark(fname)|else|call s:MakeBookmark(fname)|endif |
| 4531 | endif |
| 4532 | |
| 4533 | else |
| 4534 | " bookmark specified files |
| 4535 | " attempts to infer if working remote or local |
| 4536 | " by deciding if the current file begins with an url |
| 4537 | " Globbing cannot be done remotely. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4538 | let islocal= expand("%") !~ '^\a\{3,}://' |
| 4539 | " call Decho("bookmark specified file".((a:0>1)? "s" : ""),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4540 | let i = 1 |
| 4541 | while i <= a:0 |
| 4542 | if islocal |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4543 | if v:version > 704 || (v:version == 704 && has("patch656")) |
| 4544 | let mbfiles= glob(fnameescape(a:{i}),0,1,1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4545 | else |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4546 | let mbfiles= glob(fnameescape(a:{i}),0,1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4547 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4548 | else |
| 4549 | let mbfiles= [a:{i}] |
| 4550 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4551 | " call Decho("mbfiles".string(mbfiles),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4552 | for mbfile in mbfiles |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4553 | " call Decho("mbfile<".mbfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4554 | if a:del|call s:DeleteBookmark(mbfile)|else|call s:MakeBookmark(mbfile)|endif |
| 4555 | endfor |
| 4556 | let i= i + 1 |
| 4557 | endwhile |
| 4558 | endif |
| 4559 | |
| 4560 | " update the menu |
| 4561 | call s:NetrwBookmarkMenu() |
| 4562 | |
| 4563 | " call Dret("s:NetrwBookmark") |
| 4564 | endfun |
| 4565 | |
| 4566 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4567 | " s:NetrwBookmarkMenu: Uses menu priorities {{{2 |
| 4568 | " .2.[cnt] for bookmarks, and |
| 4569 | " .3.[cnt] for history |
| 4570 | " (see s:NetrwMenu()) |
| 4571 | fun! s:NetrwBookmarkMenu() |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4572 | if !exists("s:netrw_menucnt") |
| 4573 | return |
| 4574 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4575 | " call Dfunc("NetrwBookmarkMenu() histcnt=".g:netrw_dirhist_cnt." menucnt=".s:netrw_menucnt) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4576 | |
| 4577 | " the following test assures that gvim is running, has menus available, and has menus enabled. |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 4578 | if has("gui") && has("menu") && has("gui_running") && &go =~# 'm' && g:netrw_menu |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4579 | if exists("g:NetrwTopLvlMenu") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4580 | " call Decho("removing ".g:NetrwTopLvlMenu."Bookmarks menu item(s)",'~'.expand("<slnum>")) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4581 | exe 'sil! unmenu '.g:NetrwTopLvlMenu.'Bookmarks' |
| 4582 | exe 'sil! unmenu '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History.Bookmark\ Delete' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4583 | endif |
| 4584 | if !exists("s:netrw_initbookhist") |
| 4585 | call s:NetrwBookHistRead() |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4586 | endif |
| 4587 | |
| 4588 | " show bookmarked places |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4589 | if exists("g:netrw_bookmarklist") && g:netrw_bookmarklist != [] && g:netrw_dirhistmax > 0 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4590 | let cnt= 1 |
| 4591 | for bmd in g:netrw_bookmarklist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4592 | " call Decho('sil! menu '.g:NetrwMenuPriority.".2.".cnt." ".g:NetrwTopLvlMenu.'Bookmark.'.bmd.' :e '.bmd,'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4593 | let bmd= escape(bmd,g:netrw_menu_escape) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4594 | |
| 4595 | " show bookmarks for goto menu |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4596 | exe 'sil! menu '.g:NetrwMenuPriority.".2.".cnt." ".g:NetrwTopLvlMenu.'Bookmarks.'.bmd.' :e '.bmd."\<cr>" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4597 | |
| 4598 | " show bookmarks for deletion menu |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4599 | exe 'sil! menu '.g:NetrwMenuPriority.".8.2.".cnt." ".g:NetrwTopLvlMenu.'Bookmarks\ and\ History.Bookmark\ Delete.'.bmd.' '.cnt."mB" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4600 | let cnt= cnt + 1 |
| 4601 | endfor |
| 4602 | |
| 4603 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4604 | |
| 4605 | " show directory browsing history |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 4606 | if g:netrw_dirhistmax > 0 |
| 4607 | let cnt = g:netrw_dirhist_cnt |
| 4608 | let first = 1 |
| 4609 | let histcnt = 0 |
| 4610 | while ( first || cnt != g:netrw_dirhist_cnt ) |
| 4611 | let histcnt = histcnt + 1 |
| 4612 | let priority = g:netrw_dirhist_cnt + histcnt |
| 4613 | if exists("g:netrw_dirhist_{cnt}") |
| 4614 | let histdir= escape(g:netrw_dirhist_{cnt},g:netrw_menu_escape) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4615 | " call Decho('sil! menu '.g:NetrwMenuPriority.".3.".priority." ".g:NetrwTopLvlMenu.'History.'.histdir.' :e '.histdir,'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 4616 | exe 'sil! menu '.g:NetrwMenuPriority.".3.".priority." ".g:NetrwTopLvlMenu.'History.'.histdir.' :e '.histdir."\<cr>" |
| 4617 | endif |
| 4618 | let first = 0 |
| 4619 | let cnt = ( cnt - 1 ) % g:netrw_dirhistmax |
| 4620 | if cnt < 0 |
| 4621 | let cnt= cnt + g:netrw_dirhistmax |
| 4622 | endif |
| 4623 | endwhile |
| 4624 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4625 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4626 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4627 | " call Dret("NetrwBookmarkMenu") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4628 | endfun |
| 4629 | |
| 4630 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4631 | " s:NetrwBrowseChgDir: constructs a new directory based on the current {{{2 |
| 4632 | " directory and a new directory name. Also, if the |
| 4633 | " "new directory name" is actually a file, |
| 4634 | " NetrwBrowseChgDir() edits the file. |
| 4635 | fun! s:NetrwBrowseChgDir(islocal,newdir,...) |
| 4636 | " call Dfunc("s:NetrwBrowseChgDir(islocal=".a:islocal."> newdir<".a:newdir.">) a:0=".a:0." curpos<".string(getpos("."))."> b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : "").">") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4637 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4638 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4639 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4640 | if !exists("b:netrw_curdir") |
| 4641 | " Don't try to change-directory: this can happen, for example, when netrw#ErrorMsg has been called |
| 4642 | " and the current window is the NetrwMessage window. |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4643 | let @@= ykeep |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4644 | " call Decho("b:netrw_curdir doesn't exist!",'~'.expand("<slnum>")) |
| 4645 | " call Decho("getcwd<".getcwd().">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4646 | " call Dredir("ls!","s:NetrwBrowseChgDir") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4647 | " call Dret("s:NetrwBrowseChgDir") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4648 | return |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4649 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4650 | " call Decho("b:netrw_curdir<".b:netrw_curdir.">") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4651 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4652 | " NetrwBrowseChgDir: save options and initialize {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4653 | " call Decho("saving options",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 4654 | call s:SavePosn(s:netrw_posn) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4655 | NetrwKeepj call s:NetrwOptionSave("s:") |
| 4656 | NetrwKeepj call s:NetrwSafeOptions() |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4657 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4658 | let dirname = substitute(b:netrw_curdir,'\\','/','ge') |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4659 | else |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4660 | let dirname = b:netrw_curdir |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4661 | endif |
| 4662 | let newdir = a:newdir |
| 4663 | let dolockout = 0 |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4664 | let dorestore = 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4665 | " call Decho("dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4666 | |
| 4667 | " ignore <cr>s when done in the banner |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4668 | " call Decho('ignore [return]s when done in banner (g:netrw_banner='.g:netrw_banner.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4669 | if g:netrw_banner |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4670 | " call Decho("w:netrw_bannercnt=".(exists("w:netrw_bannercnt")? w:netrw_bannercnt : 'n/a')." line(.)#".line('.')." line($)#".line("#"),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4671 | if exists("w:netrw_bannercnt") && line(".") < w:netrw_bannercnt && line("$") >= w:netrw_bannercnt |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4672 | if getline(".") =~# 'Quick Help' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4673 | " call Decho("#1: quickhelp=".g:netrw_quickhelp." ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4674 | let g:netrw_quickhelp= (g:netrw_quickhelp + 1)%len(s:QuickHelp) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4675 | " call Decho("#2: quickhelp=".g:netrw_quickhelp." ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4676 | setl ma noro nowrap |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4677 | NetrwKeepj call setline(line('.'),'" Quick Help: <F1>:help '.s:QuickHelp[g:netrw_quickhelp]) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4678 | setl noma nomod nowrap |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4679 | NetrwKeepj call s:NetrwOptionRestore("s:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4680 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4681 | endif |
| 4682 | endif |
| 4683 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4684 | " call Decho("(s:NetrwBrowseChgdir) g:netrw_banner=".g:netrw_banner." (no banner)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4685 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4686 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4687 | " set up o/s-dependent directory recognition pattern |
| 4688 | if has("amiga") |
| 4689 | let dirpat= '[\/:]$' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4690 | else |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4691 | let dirpat= '[\/]$' |
| 4692 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4693 | " call Decho("set up o/s-dependent directory recognition pattern: dirname<".dirname."> dirpat<".dirpat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4694 | |
| 4695 | if dirname !~ dirpat |
| 4696 | " apparently vim is "recognizing" that it is in a directory and |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 4697 | " is removing the trailing "/". Bad idea, so let's put it back. |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4698 | let dirname= dirname.'/' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4699 | " call Decho("adjusting dirname<".dirname.'> (put trailing "/" back)','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4700 | endif |
| 4701 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4702 | " call Decho("[newdir<".newdir."> ".((newdir =~ dirpat)? "=~" : "!~")." dirpat<".dirpat.">] && [islocal=".a:islocal."] && [newdir is ".(isdirectory(s:NetrwFile(newdir))? "" : "not ")."a directory]",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4703 | if newdir !~ dirpat && !(a:islocal && isdirectory(s:NetrwFile(s:ComposePath(dirname,newdir)))) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4704 | " ------------------------------ |
| 4705 | " NetrwBrowseChgDir: edit a file {{{3 |
| 4706 | " ------------------------------ |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4707 | " call Decho('edit-a-file: case "handling a file": newdir<'.newdir.'> !~ dirpat<'.dirpat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 4708 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4709 | " save position for benefit of Rexplore |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4710 | let s:rexposn_{bufnr("%")}= winsaveview() |
| 4711 | " call Decho("edit-a-file: saving posn to s:rexposn_".bufnr("%")."<".string(s:rexposn_{bufnr("%")}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4712 | " call Decho("edit-a-file: win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> ft=".&ft,'~'.expand("<slnum>")) |
| 4713 | " call Decho("edit-a-file: w:netrw_liststyle=".(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a')." w:netrw_treedict:".(exists("w:netrw_treedict")? "exists" : 'n/a')." newdir<".newdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 4714 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4715 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") && newdir !~ '^\(/\|\a:\)' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4716 | " call Decho("edit-a-file: handle tree listing: w:netrw_treedict<".(exists("w:netrw_treedict")? string(w:netrw_treedict) : 'n/a').">",'~'.expand("<slnum>")) |
| 4717 | " call Decho("edit-a-file: newdir<".newdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4718 | let dirname= s:NetrwTreeDir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4719 | if dirname =~ '/$' |
| 4720 | let dirname= dirname.newdir |
| 4721 | else |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4722 | let dirname= dirname."/".newdir |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4723 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4724 | " call Decho("edit-a-file: dirname<".dirname.">",'~'.expand("<slnum>")) |
| 4725 | " call Decho("edit-a-file: tree listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4726 | elseif newdir =~ '^\(/\|\a:\)' |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4727 | " call Decho("edit-a-file: handle an url or path starting with /: <".newdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4728 | let dirname= newdir |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4729 | else |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4730 | let dirname= s:ComposePath(dirname,newdir) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4731 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4732 | " call Decho("edit-a-file: handling a file: dirname<".dirname."> (a:0=".a:0.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4733 | " this lets netrw#BrowseX avoid the edit |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4734 | if a:0 < 1 |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4735 | " call Decho("edit-a-file: (a:0=".a:0."<1) set up windows for editing<".fnameescape(dirname)."> didsplit=".(exists("s:didsplit")? s:didsplit : "doesn't exist"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4736 | NetrwKeepj call s:NetrwOptionRestore("s:") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4737 | let curdir= b:netrw_curdir |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4738 | if !exists("s:didsplit") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4739 | " call Decho("edit-a-file: s:didsplit does not exist; g:netrw_browse_split=".string(g:netrw_browse_split)." win#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4740 | if type(g:netrw_browse_split) == 3 |
| 4741 | " open file in server |
| 4742 | " Note that g:netrw_browse_split is a List: [servername,tabnr,winnr] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4743 | " call Decho("edit-a-file: open file in server",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4744 | call s:NetrwServerEdit(a:islocal,dirname) |
| 4745 | " call Dret("s:NetrwBrowseChgDir") |
| 4746 | return |
| 4747 | elseif g:netrw_browse_split == 1 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4748 | " horizontally splitting the window first |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4749 | " call Decho("edit-a-file: horizontally splitting window prior to edit",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4750 | keepalt new |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4751 | if !&ea |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4752 | keepalt wincmd _ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4753 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4754 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4755 | elseif g:netrw_browse_split == 2 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4756 | " vertically splitting the window first |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4757 | " call Decho("edit-a-file: vertically splitting window prior to edit",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4758 | keepalt rightb vert new |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4759 | if !&ea |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4760 | keepalt wincmd | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4761 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4762 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4763 | elseif g:netrw_browse_split == 3 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4764 | " open file in new tab |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4765 | " call Decho("edit-a-file: opening new tab prior to edit",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 4766 | keepalt tabnew |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4767 | if !exists("b:netrw_curdir") |
| 4768 | let b:netrw_curdir= getcwd() |
| 4769 | endif |
| 4770 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4771 | elseif g:netrw_browse_split == 4 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4772 | " act like "P" (ie. open previous window) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4773 | " call Decho("edit-a-file: use previous window for edit",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4774 | if s:NetrwPrevWinOpen(2) == 3 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4775 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4776 | " call Dret("s:NetrwBrowseChgDir") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4777 | return |
| 4778 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4779 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4780 | else |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4781 | " handling a file, didn't split, so remove menu |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4782 | " call Decho("edit-a-file: handling a file+didn't split, so remove menu",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4783 | call s:NetrwMenu(0) |
| 4784 | " optional change to window |
| 4785 | if g:netrw_chgwin >= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4786 | " call Decho("edit-a-file: changing window to #".g:netrw_chgwin,'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4787 | if winnr("$")+1 == g:netrw_chgwin |
| 4788 | " if g:netrw_chgwin is set to one more than the last window, then |
| 4789 | " vertically split the last window to make that window available. |
| 4790 | let curwin= winnr() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4791 | exe "NetrwKeepj keepalt ".winnr("$")."wincmd w" |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4792 | vs |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4793 | exe "NetrwKeepj keepalt ".g:netrw_chgwin."wincmd ".curwin |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4794 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4795 | exe "NetrwKeepj keepalt ".g:netrw_chgwin."wincmd w" |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4796 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4797 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4798 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4799 | endif |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 4800 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4801 | " the point where netrw actually edits the (local) file |
| 4802 | " if its local only: LocalBrowseCheck() doesn't edit a file, but NetrwBrowse() will |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4803 | " no keepalt to support :e # to return to a directory listing |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4804 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4805 | " call Decho("edit-a-file: edit local file: exe e! ".fnameescape(dirname),'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4806 | " some like c-^ to return to the last edited file |
| 4807 | " others like c-^ to return to the netrw buffer |
| 4808 | if exists("g:netrw_altfile") && g:netrw_altfile |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4809 | exe "NetrwKeepj keepalt e! ".fnameescape(dirname) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4810 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4811 | exe "NetrwKeepj e! ".fnameescape(dirname) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4812 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4813 | " call Decho("edit-a-file: after e! ".dirname.": hidden=".&hidden." bufhidden<".&bufhidden."> mod=".&mod,'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4814 | call s:NetrwCursor() |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 4815 | if &hidden || &bufhidden == "hide" |
| 4816 | " file came from vim's hidden storage. Don't "restore" options with it. |
| 4817 | let dorestore= 0 |
| 4818 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4819 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4820 | " call Decho("edit-a-file: remote file: NetrwBrowse will edit it",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4821 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4822 | let dolockout= 1 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4823 | |
| 4824 | " handle g:Netrw_funcref -- call external-to-netrw functions |
| 4825 | " This code will handle g:Netrw_funcref as an individual function reference |
| 4826 | " or as a list of function references. It will ignore anything that's not |
| 4827 | " a function reference. See :help Funcref for information about function references. |
| 4828 | if exists("g:Netrw_funcref") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4829 | " call Decho("edit-a-file: handle optional Funcrefs",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4830 | if type(g:Netrw_funcref) == 2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4831 | " call Decho("edit-a-file: handling a g:Netrw_funcref",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4832 | NetrwKeepj call g:Netrw_funcref() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4833 | elseif type(g:Netrw_funcref) == 3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4834 | " call Decho("edit-a-file: handling a list of g:Netrw_funcrefs",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4835 | for Fncref in g:Netrw_funcref |
| 4836 | if type(FncRef) == 2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4837 | NetrwKeepj call FncRef() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4838 | endif |
| 4839 | endfor |
| 4840 | endif |
| 4841 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4842 | endif |
| 4843 | |
| 4844 | elseif newdir =~ '^/' |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4845 | " ---------------------------------------------------- |
| 4846 | " NetrwBrowseChgDir: just go to the new directory spec {{{3 |
| 4847 | " ---------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4848 | " call Decho('goto-newdir: case "just go to new directory spec": newdir<'.newdir.'>','~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4849 | let dirname = newdir |
| 4850 | NetrwKeepj call s:SetRexDir(a:islocal,dirname) |
| 4851 | NetrwKeepj call s:NetrwOptionRestore("s:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4852 | norm! m` |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4853 | |
| 4854 | elseif newdir == './' |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4855 | " --------------------------------------------- |
| 4856 | " NetrwBrowseChgDir: refresh the directory list {{{3 |
| 4857 | " --------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4858 | " call Decho('refresh-dirlist: case "refresh directory listing": newdir == "./"','~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4859 | NetrwKeepj call s:SetRexDir(a:islocal,dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4860 | norm! m` |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4861 | |
| 4862 | elseif newdir == '../' |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4863 | " -------------------------------------- |
| 4864 | " NetrwBrowseChgDir: go up one directory {{{3 |
| 4865 | " -------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4866 | " call Decho('go-up: case "go up one directory": newdir == "../"','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4867 | |
| 4868 | if w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") |
| 4869 | " force a refresh |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4870 | " call Decho("go-up: clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
| 4871 | " call Decho("go-up: setl noro ma",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 4872 | setl noro ma |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4873 | NetrwKeepj %d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4874 | endif |
| 4875 | |
| 4876 | if has("amiga") |
| 4877 | " amiga |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4878 | " call Decho('go-up: case "go up one directory": newdir == "../" and amiga','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4879 | if a:islocal |
| 4880 | let dirname= substitute(dirname,'^\(.*[/:]\)\([^/]\+$\)','\1','') |
| 4881 | let dirname= substitute(dirname,'/$','','') |
| 4882 | else |
| 4883 | let dirname= substitute(dirname,'^\(.*[/:]\)\([^/]\+/$\)','\1','') |
| 4884 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4885 | " call Decho("go-up: amiga: dirname<".dirname."> (go up one dir)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4886 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4887 | elseif !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 4888 | " windows |
| 4889 | if a:islocal |
| 4890 | let dirname= substitute(dirname,'^\(.*\)/\([^/]\+\)/$','\1','') |
| 4891 | if dirname == "" |
| 4892 | let dirname= '/' |
| 4893 | endif |
| 4894 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4895 | let dirname= substitute(dirname,'^\(\a\{3,}://.\{-}/\{1,2}\)\(.\{-}\)\([^/]\+\)/$','\1\2','') |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4896 | endif |
| 4897 | if dirname =~ '^\a:$' |
| 4898 | let dirname= dirname.'/' |
| 4899 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4900 | " call Decho("go-up: windows: dirname<".dirname."> (go up one dir)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 4901 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4902 | else |
| 4903 | " unix or cygwin |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4904 | " call Decho('go-up: case "go up one directory": newdir == "../" and unix or cygwin','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4905 | if a:islocal |
| 4906 | let dirname= substitute(dirname,'^\(.*\)/\([^/]\+\)/$','\1','') |
| 4907 | if dirname == "" |
| 4908 | let dirname= '/' |
| 4909 | endif |
| 4910 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4911 | let dirname= substitute(dirname,'^\(\a\{3,}://.\{-}/\{1,2}\)\(.\{-}\)\([^/]\+\)/$','\1\2','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4912 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4913 | " call Decho("go-up: unix: dirname<".dirname."> (go up one dir)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4914 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4915 | NetrwKeepj call s:SetRexDir(a:islocal,dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4916 | norm m` |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4917 | |
| 4918 | elseif exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4919 | " -------------------------------------- |
| 4920 | " NetrwBrowseChgDir: Handle Tree Listing {{{3 |
| 4921 | " -------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4922 | " call Decho('tree-list: case liststyle is TREELIST and w:netrw_treedict exists','~'.expand("<slnum>")) |
| 4923 | " force a refresh (for TREELIST, NetrwTreeDir() will force the refresh) |
| 4924 | " call Decho("tree-list: setl noro ma",'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 4925 | setl noro ma |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4926 | if !(exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("b:netrw_curdir")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4927 | " call Decho("tree-list: clear buffer<".expand("%")."> with :%d (force refresh)",'~'.expand("<slnum>")) |
| 4928 | NetrwKeepj %d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4929 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4930 | let treedir = s:NetrwTreeDir(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4931 | " call Decho("tree-list: treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 4932 | let s:treecurpos = winsaveview() |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4933 | let haskey = 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4934 | " call Decho("tree-list: w:netrw_treedict<".string(w:netrw_treedict).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4935 | |
| 4936 | " search treedict for tree dir as-is |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4937 | " call Decho("tree-list: search treedict for tree dir as-is",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4938 | if has_key(w:netrw_treedict,treedir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4939 | " call Decho('tree-list: ....searched for treedir<'.treedir.'> : found it!','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4940 | let haskey= 1 |
| 4941 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4942 | " call Decho('tree-list: ....searched for treedir<'.treedir.'> : not found','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4943 | endif |
| 4944 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4945 | " search treedict for treedir with a [/@] appended |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4946 | " call Decho("tree-list: search treedict for treedir with a [/@] appended",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4947 | if !haskey && treedir !~ '[/@]$' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4948 | if has_key(w:netrw_treedict,treedir."/") |
| 4949 | let treedir= treedir."/" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4950 | " call Decho('tree-list: ....searched.for treedir<'.treedir.'> found it!','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4951 | let haskey = 1 |
| 4952 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4953 | " call Decho('tree-list: ....searched for treedir<'.treedir.'/> : not found','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4954 | endif |
| 4955 | endif |
| 4956 | |
| 4957 | " search treedict for treedir with any trailing / elided |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 4958 | " call Decho("tree-list: search treedict for treedir with any trailing / elided",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4959 | if !haskey && treedir =~ '/$' |
| 4960 | let treedir= substitute(treedir,'/$','','') |
| 4961 | if has_key(w:netrw_treedict,treedir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4962 | " call Decho('tree-list: ....searched.for treedir<'.treedir.'> found it!','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4963 | let haskey = 1 |
| 4964 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4965 | " call Decho('tree-list: ....searched for treedir<'.treedir.'> : not found','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4966 | endif |
| 4967 | endif |
| 4968 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4969 | " call Decho("haskey=".haskey,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4970 | if haskey |
| 4971 | " close tree listing for selected subdirectory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4972 | " call Decho("tree-list: closing selected subdirectory<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4973 | call remove(w:netrw_treedict,treedir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4974 | " call Decho("tree-list: removed entry<".treedir."> from treedict",'~'.expand("<slnum>")) |
| 4975 | " call Decho("tree-list: yielding treedict<".string(w:netrw_treedict).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 4976 | let dirname= w:netrw_treetop |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4977 | else |
| 4978 | " go down one directory |
| 4979 | let dirname= substitute(treedir,'/*$','/','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4980 | " call Decho("tree-list: go down one dir: treedir<".treedir.">",'~'.expand("<slnum>")) |
| 4981 | " call Decho("tree-list: ... : dirname<".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4982 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4983 | NetrwKeepj call s:SetRexDir(a:islocal,dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4984 | " call Decho("setting s:treeforceredraw to true",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 4985 | let s:treeforceredraw = 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 4986 | |
| 4987 | else |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4988 | " ---------------------------------------- |
| 4989 | " NetrwBrowseChgDir: Go down one directory {{{3 |
| 4990 | " ---------------------------------------- |
| 4991 | let dirname = s:ComposePath(dirname,newdir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4992 | " call Decho("go down one dir: dirname<".dirname."> newdir<".newdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 4993 | NetrwKeepj call s:SetRexDir(a:islocal,dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 4994 | norm m` |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 4995 | endif |
| 4996 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 4997 | " -------------------------------------- |
| 4998 | " NetrwBrowseChgDir: Restore and Cleanup {{{3 |
| 4999 | " -------------------------------------- |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5000 | if dorestore |
| 5001 | " dorestore is zero'd when a local file was hidden or bufhidden; |
| 5002 | " in such a case, we want to keep whatever settings it may have. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5003 | " call Decho("doing option restore (dorestore=".dorestore.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5004 | NetrwKeepj call s:NetrwOptionRestore("s:") |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5005 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5006 | " call Decho("skipping option restore (dorestore==0): hidden=".&hidden." bufhidden=".&bufhidden." mod=".&mod,'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5007 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5008 | if dolockout && dorestore |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5009 | " call Decho("restore: filewritable(dirname<".dirname.">)=".filewritable(dirname),'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 5010 | if filewritable(dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5011 | " call Decho("restore: doing modification lockout settings: ma nomod noro",'~'.expand("<slnum>")) |
| 5012 | " call Decho("restore: setl ma nomod noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5013 | setl ma noro nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5014 | " call Decho("restore: ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 5015 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5016 | " call Decho("restore: doing modification lockout settings: ma nomod ro",'~'.expand("<slnum>")) |
| 5017 | " call Decho("restore: setl ma nomod noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 5018 | setl ma ro nomod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5019 | " call Decho("restore: ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 5020 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5021 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5022 | call s:RestorePosn(s:netrw_posn) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5023 | let @@= ykeep |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5024 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5025 | " call Dret("s:NetrwBrowseChgDir <".dirname."> : curpos<".string(getpos(".")).">") |
| 5026 | return dirname |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5027 | endfun |
| 5028 | |
| 5029 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5030 | " s:NetrwBrowseUpDir: implements the "-" mappings {{{2 |
| 5031 | " for thin, long, and wide: cursor placed just after banner |
| 5032 | " for tree, keeps cursor on current filename |
| 5033 | fun! s:NetrwBrowseUpDir(islocal) |
| 5034 | " call Dfunc("s:NetrwBrowseUpDir(islocal=".a:islocal.")") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5035 | if exists("w:netrw_bannercnt") && line(".") < w:netrw_bannercnt-1 |
| 5036 | " this test needed because occasionally this function seems to be incorrectly called |
| 5037 | " when multiple leftmouse clicks are taken when atop the one line help in the banner. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5038 | " I'm allowing the very bottom line to permit a "-" exit so that one may escape empty |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5039 | " directories. |
| 5040 | " call Dret("s:NetrwBrowseUpDir : cursor not in file area") |
| 5041 | return |
| 5042 | endif |
| 5043 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5044 | norm! 0 |
| 5045 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5046 | " call Decho("case: treestyle",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5047 | let curline= getline(".") |
| 5048 | let swwline= winline() - 1 |
| 5049 | if exists("w:netrw_treetop") |
| 5050 | let b:netrw_curdir= w:netrw_treetop |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5051 | elseif exists("b:netrw_curdir") |
| 5052 | let w:netrw_treetop= b:netrw_curdir |
| 5053 | else |
| 5054 | let w:netrw_treetop= getcwd() |
| 5055 | let b:netrw_curdir = w:netrw_treetop |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5056 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5057 | let curfile = getline(".") |
| 5058 | let curpath = s:NetrwTreePath(w:netrw_treetop) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5059 | if a:islocal |
| 5060 | call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,'../')) |
| 5061 | else |
| 5062 | call s:NetrwBrowse(0,s:NetrwBrowseChgDir(0,'../')) |
| 5063 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5064 | " call Decho("looking for curfile<^".s:treedepthstring.curfile.">",'~'.expand("<slnum>")) |
| 5065 | " call Decho("having curpath<".curpath.">",'~'.expand("<slnum>")) |
| 5066 | if w:netrw_treetop == '/' |
| 5067 | keepj call search('^\M'.curfile,"w") |
| 5068 | elseif curfile == '../' |
| 5069 | keepj call search('^\M'.curfile,"wb") |
| 5070 | else |
| 5071 | " call Decho("search(^\\M".s:treedepthstring.curfile.") backwards")) |
| 5072 | while 1 |
| 5073 | keepj call search('^\M'.s:treedepthstring.curfile,"wb") |
| 5074 | let treepath= s:NetrwTreePath(w:netrw_treetop) |
| 5075 | " call Decho("..current treepath<".treepath.">",'~'.expand("<slnum>")) |
| 5076 | if treepath == curpath |
| 5077 | break |
| 5078 | endif |
| 5079 | endwhile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5080 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5081 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5082 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5083 | " call Decho("case: not treestyle",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5084 | call s:SavePosn(s:netrw_posn) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5085 | if exists("b:netrw_curdir") |
| 5086 | let curdir= b:netrw_curdir |
| 5087 | else |
| 5088 | let curdir= expand(getcwd()) |
| 5089 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5090 | if a:islocal |
| 5091 | call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,'../')) |
| 5092 | else |
| 5093 | call s:NetrwBrowse(0,s:NetrwBrowseChgDir(0,'../')) |
| 5094 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5095 | call s:RestorePosn(s:netrw_posn) |
| 5096 | let curdir= substitute(curdir,'^.*[\/]','','') |
| 5097 | call search('\<'.curdir.'/','wc') |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 5098 | endif |
| 5099 | " call Dret("s:NetrwBrowseUpDir") |
| 5100 | endfun |
| 5101 | |
| 5102 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5103 | " netrw#BrowseX: (implements "x") executes a special "viewer" script or program for the {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5104 | " given filename; typically this means given their extension. |
| 5105 | " 0=local, 1=remote |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5106 | fun! netrw#BrowseX(fname,remote) |
| 5107 | " call Dfunc("netrw#BrowseX(fname<".a:fname."> remote=".a:remote.")") |
| 5108 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5109 | " if its really just a local directory, then do a "gf" instead |
| 5110 | if (a:remote == 0 && isdirectory(a:fname)) || (a:remote == 1 && a:fname =~ '/$' && a:fname !~ '^https\=:') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5111 | norm! gf |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5112 | " call Dret("(netrw#BrowseX) did gf instead") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5113 | endif |
| 5114 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5115 | let ykeep = @@ |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5116 | let screenposn = winsaveview() |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5117 | " call Decho("(netrw#BrowseX) saving posn to screenposn<".string(screenposn).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5118 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5119 | " need to save and restore aw setting as gx can invoke this function from non-netrw buffers |
| 5120 | let awkeep = &aw |
| 5121 | set noaw |
| 5122 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5123 | " special core dump handler |
| 5124 | if a:fname =~ '/core\(\.\d\+\)\=$' |
| 5125 | if exists("g:Netrw_corehandler") |
| 5126 | if type(g:Netrw_corehandler) == 2 |
| 5127 | " g:Netrw_corehandler is a function reference (see :help Funcref) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5128 | " call Decho("(netrw#BrowseX) g:Netrw_corehandler is a funcref",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5129 | call g:Netrw_corehandler(s:NetrwFile(a:fname)) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5130 | elseif type(g:Netrw_corehandler) == 3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5131 | " g:Netrw_corehandler is a List of function references (see :help Funcref) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5132 | " call Decho("(netrw#BrowseX) g:Netrw_corehandler is a List",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5133 | for Fncref in g:Netrw_corehandler |
| 5134 | if type(FncRef) == 2 |
| 5135 | call FncRef(a:fname) |
| 5136 | endif |
| 5137 | endfor |
| 5138 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5139 | " call Decho("(netrw#BrowseX) restoring posn: screenposn<".string(screenposn).">,'~'.expand("<slnum>"))" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5140 | call winrestview(screenposn) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5141 | let @@= ykeep |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5142 | let &aw= awkeep |
| 5143 | " call Dret("netrw#BrowseX : coredump handler invoked") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5144 | return |
| 5145 | endif |
| 5146 | endif |
| 5147 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5148 | " set up the filename |
| 5149 | " (lower case the extension, make a local copy of a remote file) |
| 5150 | let exten= substitute(a:fname,'.*\.\(.\{-}\)','\1','e') |
| 5151 | if has("win32") || has("win95") || has("win64") || has("win16") |
| 5152 | let exten= substitute(exten,'^.*$','\L&\E','') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5153 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5154 | if exten =~ "[\\/]" |
| 5155 | let exten= "" |
| 5156 | endif |
| 5157 | " call Decho("(netrw#BrowseX) exten<".exten.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5158 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5159 | if a:remote == 1 |
| 5160 | " create a local copy |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5161 | " call Decho("(netrw#BrowseX) remote: a:remote=".a:remote.": create a local copy of <".a:fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5162 | setl bh=delete |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5163 | call netrw#NetRead(3,a:fname) |
| 5164 | " attempt to rename tempfile |
| 5165 | let basename= substitute(a:fname,'^\(.*\)/\(.*\)\.\([^.]*\)$','\2','') |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5166 | let newname = substitute(s:netrw_tmpfile,'^\(.*\)/\(.*\)\.\([^.]*\)$','\1/'.basename.'.\3','') |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5167 | " call Decho("(netrw#BrowseX) basename<".basename.">",'~'.expand("<slnum>")) |
| 5168 | " call Decho("(netrw#BrowseX) newname <".newname.">",'~'.expand("<slnum>")) |
| 5169 | if s:netrw_tmpfile != newname && newname != "" |
| 5170 | if rename(s:netrw_tmpfile,newname) == 0 |
| 5171 | " renaming succeeded |
| 5172 | " call Decho("(netrw#BrowseX) renaming succeeded (tmpfile<".s:netrw_tmpfile."> to <".newname.">)") |
| 5173 | let fname= newname |
| 5174 | else |
| 5175 | " renaming failed |
| 5176 | " call Decho("(netrw#BrowseX) renaming failed (tmpfile<".s:netrw_tmpfile."> to <".newname.">)") |
| 5177 | let fname= s:netrw_tmpfile |
| 5178 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5179 | else |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5180 | let fname= s:netrw_tmpfile |
| 5181 | endif |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 5182 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5183 | " call Decho("(netrw#BrowseX) local: a:remote=".a:remote.": handling local copy of <".a:fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 5184 | let fname= a:fname |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5185 | " special ~ handler for local |
| 5186 | if fname =~ '^\~' && expand("$HOME") != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5187 | " call Decho('invoking special ~ handler','~'.expand("<slnum>")) |
| 5188 | let fname= s:NetrwFile(substitute(fname,'^\~',expand("$HOME"),'')) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5189 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5190 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5191 | " call Decho("(netrw#BrowseX) fname<".fname.">",'~'.expand("<slnum>")) |
| 5192 | " call Decho("(netrw#BrowseX) exten<".exten."> "."netrwFileHandlers#NFH_".exten."():exists=".exists("*netrwFileHandlers#NFH_".exten),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5193 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 5194 | " set up redirection (avoids browser messages) |
| 5195 | " by default, g:netrw_suppress_gx_mesg is true |
| 5196 | if g:netrw_suppress_gx_mesg |
| 5197 | if &srr =~ "%s" |
| 5198 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
| 5199 | let redir= substitute(&srr,"%s","nul","") |
| 5200 | else |
| 5201 | let redir= substitute(&srr,"%s","/dev/null","") |
| 5202 | endif |
| 5203 | elseif (has("win32") || has("win95") || has("win64") || has("win16")) |
| 5204 | let redir= &srr . "nul" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5205 | else |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 5206 | let redir= &srr . "/dev/null" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5207 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5208 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5209 | " call Decho("(netrw#BrowseX) set up redirection: redir{".redir."} srr{".&srr."}",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5210 | |
| 5211 | " extract any viewing options. Assumes that they're set apart by quotes. |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5212 | " call Decho("(netrw#BrowseX) extract any viewing options",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5213 | if exists("g:netrw_browsex_viewer") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5214 | " call Decho("(netrw#BrowseX) g:netrw_browsex_viewer<".g:netrw_browsex_viewer.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5215 | if g:netrw_browsex_viewer =~ '\s' |
| 5216 | let viewer = substitute(g:netrw_browsex_viewer,'\s.*$','','') |
| 5217 | let viewopt = substitute(g:netrw_browsex_viewer,'^\S\+\s*','','')." " |
| 5218 | let oviewer = '' |
| 5219 | let cnt = 1 |
| 5220 | while !executable(viewer) && viewer != oviewer |
| 5221 | let viewer = substitute(g:netrw_browsex_viewer,'^\(\(^\S\+\s\+\)\{'.cnt.'}\S\+\)\(.*\)$','\1','') |
| 5222 | let viewopt = substitute(g:netrw_browsex_viewer,'^\(\(^\S\+\s\+\)\{'.cnt.'}\S\+\)\(.*\)$','\3','')." " |
| 5223 | let cnt = cnt + 1 |
| 5224 | let oviewer = viewer |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5225 | " call Decho("(netrw#BrowseX) !exe: viewer<".viewer."> viewopt<".viewopt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5226 | endwhile |
| 5227 | else |
| 5228 | let viewer = g:netrw_browsex_viewer |
| 5229 | let viewopt = "" |
| 5230 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5231 | " call Decho("(netrw#BrowseX) viewer<".viewer."> viewopt<".viewopt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5232 | endif |
| 5233 | |
| 5234 | " execute the file handler |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5235 | " call Decho("(netrw#BrowseX) execute the file handler (if any)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5236 | if exists("g:netrw_browsex_viewer") && g:netrw_browsex_viewer == '-' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5237 | " call Decho("(netrw#BrowseX) g:netrw_browsex_viewer<".g:netrw_browsex_viewer.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5238 | let ret= netrwFileHandlers#Invoke(exten,fname) |
| 5239 | |
| 5240 | elseif exists("g:netrw_browsex_viewer") && executable(viewer) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5241 | " call Decho("(netrw#BrowseX) g:netrw_browsex_viewer<".g:netrw_browsex_viewer.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5242 | call s:NetrwExe("sil !".viewer." ".viewopt.s:ShellEscape(fname,1).redir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5243 | let ret= v:shell_error |
| 5244 | |
| 5245 | elseif has("win32") || has("win64") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5246 | " call Decho("(netrw#BrowseX) win".(has("win32")? "32" : "64")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5247 | if executable("start") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5248 | call s:NetrwExe('sil! !start rundll32 url.dll,FileProtocolHandler '.s:ShellEscape(fname,1)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5249 | elseif executable("rundll32") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5250 | call s:NetrwExe('sil! !rundll32 url.dll,FileProtocolHandler '.s:ShellEscape(fname,1)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5251 | else |
| 5252 | call netrw#ErrorMsg(s:WARNING,"rundll32 not on path",74) |
| 5253 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5254 | " call inputsave()|call input("Press <cr> to continue")|call inputrestore() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5255 | let ret= v:shell_error |
| 5256 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5257 | elseif has("win32unix") |
| 5258 | let winfname= 'c:\cygwin'.substitute(fname,'/','\\','g') |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5259 | " call Decho("(netrw#BrowseX) cygwin: winfname<".s:ShellEscape(winfname,1).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5260 | if executable("start") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5261 | call s:NetrwExe('sil !start rundll32 url.dll,FileProtocolHandler '.s:ShellEscape(winfname,1)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5262 | elseif executable("rundll32") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5263 | call s:NetrwExe('sil !rundll32 url.dll,FileProtocolHandler '.s:ShellEscape(winfname,1)) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5264 | elseif executable("cygstart") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5265 | call s:NetrwExe('sil !cygstart '.s:ShellEscape(fname,1)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5266 | else |
| 5267 | call netrw#ErrorMsg(s:WARNING,"rundll32 not on path",74) |
| 5268 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5269 | " call inputsave()|call input("Press <cr> to continue")|call inputrestore() |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5270 | let ret= v:shell_error |
| 5271 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5272 | elseif has("unix") && executable("kfmclient") && s:CheckIfKde() |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5273 | " call Decho("(netrw#BrowseX) unix and kfmclient",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5274 | call s:NetrwExe("sil !kfmclient exec ".s:ShellEscape(fname,1)." ".redir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5275 | let ret= v:shell_error |
| 5276 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5277 | elseif has("unix") && executable("exo-open") && executable("xdg-open") && executable("setsid") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5278 | " call Decho("(netrw#BrowseX) unix, exo-open, xdg-open",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5279 | call s:NetrwExe("sil !setsid xdg-open ".s:ShellEscape(fname,1).redir) |
| 5280 | let ret= v:shell_error |
| 5281 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5282 | elseif has("unix") && $DESKTOP_SESSION == "mate" && executable("atril") |
| 5283 | " call Decho("(netrw#BrowseX) unix and atril",'~'.expand("<slnum>")) |
| 5284 | call s:NetrwExe("sil !atril ".s:ShellEscape(fname,1).redir) |
| 5285 | let ret= v:shell_error |
| 5286 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5287 | elseif has("unix") && executable("xdg-open") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5288 | " call Decho("(netrw#BrowseX) unix and xdg-open",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5289 | call s:NetrwExe("sil !xdg-open ".s:ShellEscape(fname,1).redir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5290 | let ret= v:shell_error |
| 5291 | |
| 5292 | elseif has("macunix") && executable("open") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5293 | " call Decho("(netrw#BrowseX) macunix and open",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5294 | call s:NetrwExe("sil !open ".s:ShellEscape(fname,1)." ".redir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5295 | let ret= v:shell_error |
| 5296 | |
| 5297 | else |
| 5298 | " netrwFileHandlers#Invoke() always returns 0 |
| 5299 | let ret= netrwFileHandlers#Invoke(exten,fname) |
| 5300 | endif |
| 5301 | |
| 5302 | " if unsuccessful, attempt netrwFileHandlers#Invoke() |
| 5303 | if ret |
| 5304 | let ret= netrwFileHandlers#Invoke(exten,fname) |
| 5305 | endif |
| 5306 | |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 5307 | " restoring redraw! after external file handlers |
| 5308 | redraw! |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5309 | |
| 5310 | " cleanup: remove temporary file, |
| 5311 | " delete current buffer if success with handler, |
| 5312 | " return to prior buffer (directory listing) |
| 5313 | " Feb 12, 2008: had to de-activiate removal of |
| 5314 | " temporary file because it wasn't getting seen. |
| 5315 | " if a:remote == 1 && fname != a:fname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5316 | "" call Decho("deleting temporary file<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 5317 | " call s:NetrwDelete(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5318 | " endif |
| 5319 | |
| 5320 | if a:remote == 1 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5321 | setl bh=delete bt=nofile |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5322 | if g:netrw_use_noswf |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5323 | setl noswf |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5324 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5325 | exe "sil! NetrwKeepj norm! \<c-o>" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5326 | " redraw! |
| 5327 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5328 | " call Decho("(netrw#BrowseX) restoring posn to screenposn<".string(screenposn).">",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5329 | call winrestview(screenposn) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5330 | let @@ = ykeep |
| 5331 | let &aw= awkeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5332 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5333 | " call Dret("netrw#BrowseX") |
| 5334 | endfun |
| 5335 | |
| 5336 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5337 | " netrw#GX: gets word under cursor for gx support {{{2 |
| 5338 | " See also: netrw#BrowseXVis |
| 5339 | " netrw#BrowseX |
| 5340 | fun! netrw#GX() |
| 5341 | " call Dfunc("netrw#GX()") |
| 5342 | if &ft == "netrw" |
| 5343 | let fname= s:NetrwGetWord() |
| 5344 | else |
| 5345 | let fname= expand((exists("g:netrw_gx")? g:netrw_gx : '<cfile>')) |
| 5346 | endif |
| 5347 | " call Dret("netrw#GX <".fname.">") |
| 5348 | return fname |
| 5349 | endfun |
| 5350 | |
| 5351 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5352 | " netrw#BrowseXVis: used by gx in visual mode to select a file for browsing {{{2 |
| 5353 | fun! netrw#BrowseXVis() |
| 5354 | " call Dfunc("netrw#BrowseXVis()") |
| 5355 | let atkeep = @@ |
| 5356 | norm! gvy |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5357 | " call Decho("@@<".@@.">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5358 | call netrw#BrowseX(@@,netrw#CheckIfRemote(@@)) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5359 | let @@ = atkeep |
| 5360 | " call Dret("netrw#BrowseXVis") |
| 5361 | endfun |
| 5362 | |
| 5363 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5364 | " s:NetrwBufRename: renames a buffer without the side effect of retaining an unlisted buffer having the old name {{{2 |
| 5365 | " Using the file command on a "[No Name]" buffer does not seem to cause the old "[No Name]" buffer |
| 5366 | " to become an unlisted buffer, so in that case don't bwipe it. |
| 5367 | fun! s:NetrwBufRename(newname) |
| 5368 | " call Dfunc("s:NetrwBufRename(newname<".a:newname.">) buf(%)#".bufnr("%")."<".bufname(bufnr("%")).">") |
| 5369 | " call Dredir("ls!","s:NetrwBufRename (before rename)") |
| 5370 | let oldbufname= bufname(bufnr("%")) |
| 5371 | " call Decho("buf#".bufnr("%").": oldbufname<".oldbufname.">",'~'.expand("<slnum>")) |
| 5372 | if oldbufname != a:newname |
| 5373 | " call Decho("do renaming (oldbufname != a:newname)",'~'.expand("<slnum>")) |
| 5374 | exe 'sil! keepj keepalt file '.fnameescape(a:newname) |
| 5375 | let oldbufnr= bufnr(oldbufname) |
| 5376 | if oldbufname != "" && oldbufnr != -1 |
| 5377 | exe "bwipe! ".oldbufnr |
| 5378 | endif |
| 5379 | endif |
| 5380 | " call Dredir("ls!","s:NetrwBufRename (after rename)") |
| 5381 | " call Dret("s:NetrwBufRename : buf#".bufnr("%").": oldname<".oldbufname."> newname<".a:newname."> expand(%)<".expand("%").">") |
| 5382 | endfun |
| 5383 | |
| 5384 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5385 | " netrw#CheckIfRemote: returns 1 if current file looks like an url, 0 else {{{2 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5386 | fun! netrw#CheckIfRemote(...) |
| 5387 | " call Dfunc("netrw#CheckIfRemote() a:0=".a:0) |
| 5388 | if a:0 > 0 |
| 5389 | let curfile= a:1 |
| 5390 | else |
| 5391 | let curfile= expand("%") |
| 5392 | endif |
| 5393 | " call Decho("curfile<".curfile.">") |
| 5394 | if curfile =~ '^\a\{3,}://' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5395 | " call Dret("netrw#CheckIfRemote 1") |
| 5396 | return 1 |
| 5397 | else |
| 5398 | " call Dret("netrw#CheckIfRemote 0") |
| 5399 | return 0 |
| 5400 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5401 | endfun |
| 5402 | |
| 5403 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5404 | " s:NetrwChgPerm: (implements "gp") change file permission {{{2 |
| 5405 | fun! s:NetrwChgPerm(islocal,curdir) |
| 5406 | " call Dfunc("s:NetrwChgPerm(islocal=".a:islocal." curdir<".a:curdir.">)") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5407 | let ykeep = @@ |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5408 | call inputsave() |
| 5409 | let newperm= input("Enter new permission: ") |
| 5410 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5411 | let chgperm= substitute(g:netrw_chgperm,'\<FILENAME\>',s:ShellEscape(expand("<cfile>")),'') |
| 5412 | let chgperm= substitute(chgperm,'\<PERM\>',s:ShellEscape(newperm),'') |
| 5413 | " call Decho("chgperm<".chgperm.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5414 | call system(chgperm) |
| 5415 | if v:shell_error != 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5416 | NetrwKeepj call netrw#ErrorMsg(1,"changing permission on file<".expand("<cfile>")."> seems to have failed",75) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5417 | endif |
| 5418 | if a:islocal |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5419 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5420 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5421 | let @@= ykeep |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5422 | " call Dret("s:NetrwChgPerm") |
| 5423 | endfun |
| 5424 | |
| 5425 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5426 | " s:CheckIfKde: checks if kdeinit is running {{{2 |
| 5427 | " Returns 0: kdeinit not running |
| 5428 | " 1: kdeinit is running |
| 5429 | fun! s:CheckIfKde() |
| 5430 | " call Dfunc("s:CheckIfKde()") |
| 5431 | " seems kde systems often have gnome-open due to dependencies, even though |
| 5432 | " gnome-open's subsidiary display tools are largely absent. Kde systems |
| 5433 | " usually have "kdeinit" running, though... (tnx Mikolaj Machowski) |
| 5434 | if !exists("s:haskdeinit") |
| 5435 | if has("unix") && executable("ps") && !has("win32unix") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5436 | let s:haskdeinit= system("ps -e") =~ '\<kdeinit' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5437 | if v:shell_error |
| 5438 | let s:haskdeinit = 0 |
| 5439 | endif |
| 5440 | else |
| 5441 | let s:haskdeinit= 0 |
| 5442 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5443 | " call Decho("setting s:haskdeinit=".s:haskdeinit,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5444 | endif |
| 5445 | |
| 5446 | " call Dret("s:CheckIfKde ".s:haskdeinit) |
| 5447 | return s:haskdeinit |
| 5448 | endfun |
| 5449 | |
| 5450 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5451 | " s:NetrwClearExplore: clear explore variables (if any) {{{2 |
| 5452 | fun! s:NetrwClearExplore() |
| 5453 | " call Dfunc("s:NetrwClearExplore()") |
| 5454 | 2match none |
| 5455 | if exists("s:explore_match") |unlet s:explore_match |endif |
| 5456 | if exists("s:explore_indx") |unlet s:explore_indx |endif |
| 5457 | if exists("s:netrw_explore_prvdir") |unlet s:netrw_explore_prvdir |endif |
| 5458 | if exists("s:dirstarstar") |unlet s:dirstarstar |endif |
| 5459 | if exists("s:explore_prvdir") |unlet s:explore_prvdir |endif |
| 5460 | if exists("w:netrw_explore_indx") |unlet w:netrw_explore_indx |endif |
| 5461 | if exists("w:netrw_explore_listlen")|unlet w:netrw_explore_listlen|endif |
| 5462 | if exists("w:netrw_explore_list") |unlet w:netrw_explore_list |endif |
| 5463 | if exists("w:netrw_explore_bufnr") |unlet w:netrw_explore_bufnr |endif |
| 5464 | " redraw! |
| 5465 | echo " " |
| 5466 | echo " " |
| 5467 | " call Dret("s:NetrwClearExplore") |
| 5468 | endfun |
| 5469 | |
| 5470 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5471 | " s:NetrwExploreListUniq: {{{2 |
| 5472 | fun! s:NetrwExploreListUniq(explist) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 5473 | " call Dfunc("s:NetrwExploreListUniq(explist<".string(a:explist).">)") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5474 | |
| 5475 | " this assumes that the list is already sorted |
| 5476 | let newexplist= [] |
| 5477 | for member in a:explist |
| 5478 | if !exists("uniqmember") || member != uniqmember |
| 5479 | let uniqmember = member |
| 5480 | let newexplist = newexplist + [ member ] |
| 5481 | endif |
| 5482 | endfor |
| 5483 | |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 5484 | " call Dret("s:NetrwExploreListUniq newexplist<".string(newexplist).">") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5485 | return newexplist |
| 5486 | endfun |
| 5487 | |
| 5488 | " --------------------------------------------------------------------- |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5489 | " s:NetrwForceChgDir: (gd support) Force treatment as a directory {{{2 |
| 5490 | fun! s:NetrwForceChgDir(islocal,newdir) |
| 5491 | " call Dfunc("s:NetrwForceChgDir(islocal=".a:islocal." newdir<".a:newdir.">)") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5492 | let ykeep= @@ |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5493 | if a:newdir !~ '/$' |
| 5494 | " ok, looks like force is needed to get directory-style treatment |
| 5495 | if a:newdir =~ '@$' |
| 5496 | let newdir= substitute(a:newdir,'@$','/','') |
| 5497 | elseif a:newdir =~ '[*=|\\]$' |
| 5498 | let newdir= substitute(a:newdir,'.$','/','') |
| 5499 | else |
| 5500 | let newdir= a:newdir.'/' |
| 5501 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5502 | " call Decho("adjusting newdir<".newdir."> due to gd",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5503 | else |
| 5504 | " should already be getting treatment as a directory |
| 5505 | let newdir= a:newdir |
| 5506 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5507 | let newdir= s:NetrwBrowseChgDir(a:islocal,newdir) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5508 | call s:NetrwBrowse(a:islocal,newdir) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5509 | let @@= ykeep |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5510 | " call Dret("s:NetrwForceChgDir") |
| 5511 | endfun |
| 5512 | |
| 5513 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5514 | " s:NetrwGlob: does glob() if local, remote listing otherwise {{{2 |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 5515 | " direntry: this is the name of the directory. Will be fnameescape'd to prevent wildcard handling by glob() |
| 5516 | " expr : this is the expression to follow the directory. Will use s:ComposePath() |
| 5517 | " pare =1: remove the current directory from the resulting glob() filelist |
| 5518 | " =0: leave the current directory in the resulting glob() filelist |
| 5519 | fun! s:NetrwGlob(direntry,expr,pare) |
| 5520 | " call Dfunc("s:NetrwGlob(direntry<".a:direntry."> expr<".a:expr."> pare=".a:pare.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5521 | if netrw#CheckIfRemote() |
| 5522 | keepalt 1sp |
| 5523 | keepalt enew |
| 5524 | let keep_liststyle = w:netrw_liststyle |
| 5525 | let w:netrw_liststyle = s:THINLIST |
| 5526 | if s:NetrwRemoteListing() == 0 |
| 5527 | keepj keepalt %s@/@@ |
| 5528 | let filelist= getline(1,$) |
| 5529 | q! |
| 5530 | else |
| 5531 | " remote listing error -- leave treedict unchanged |
| 5532 | let filelist= w:netrw_treedict[a:direntry] |
| 5533 | endif |
| 5534 | let w:netrw_liststyle= keep_liststyle |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 5535 | elseif v:version > 704 || (v:version == 704 && has("patch656")) |
| 5536 | let filelist= glob(s:ComposePath(fnameescape(a:direntry),a:expr),0,1,1) |
| 5537 | if a:pare |
| 5538 | let filelist= map(filelist,'substitute(v:val, "^.*/", "", "")') |
| 5539 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5540 | else |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 5541 | let filelist= glob(s:ComposePath(fnameescape(a:direntry),a:expr),0,1) |
| 5542 | if a:pare |
| 5543 | let filelist= map(filelist,'substitute(v:val, "^.*/", "", "")') |
| 5544 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5545 | endif |
| 5546 | " call Dret("s:NetrwGlob ".string(filelist)) |
| 5547 | return filelist |
| 5548 | endfun |
| 5549 | |
| 5550 | " --------------------------------------------------------------------- |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5551 | " s:NetrwForceFile: (gf support) Force treatment as a file {{{2 |
| 5552 | fun! s:NetrwForceFile(islocal,newfile) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5553 | " call Dfunc("s:NetrwForceFile(islocal=".a:islocal." newdir<".a:newfile.">)") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5554 | if a:newfile =~ '[/@*=|\\]$' |
| 5555 | let newfile= substitute(a:newfile,'.$','','') |
| 5556 | else |
| 5557 | let newfile= a:newfile |
| 5558 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5559 | if a:islocal |
| 5560 | call s:NetrwBrowseChgDir(a:islocal,newfile) |
| 5561 | else |
| 5562 | call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,newfile)) |
| 5563 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5564 | " call Dret("s:NetrwForceFile") |
| 5565 | endfun |
| 5566 | |
| 5567 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5568 | " s:NetrwHide: this function is invoked by the "a" map for browsing {{{2 |
| 5569 | " and switches the hiding mode. The actual hiding is done by |
| 5570 | " s:NetrwListHide(). |
| 5571 | " g:netrw_hide= 0: show all |
| 5572 | " 1: show not-hidden files |
| 5573 | " 2: show hidden files only |
| 5574 | fun! s:NetrwHide(islocal) |
| 5575 | " call Dfunc("NetrwHide(islocal=".a:islocal.") g:netrw_hide=".g:netrw_hide) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5576 | let ykeep= @@ |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5577 | let svpos= winsaveview() |
| 5578 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5579 | |
| 5580 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5581 | " call Decho("((g:netrw_hide == 1)? "unhide" : "hide")." files in markfilelist<".string(s:netrwmarkfilelist_{bufnr("%")}).">",'~'.expand("<slnum>")) |
| 5582 | " call Decho("g:netrw_list_hide<".g:netrw_list_hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5583 | |
| 5584 | " hide the files in the markfile list |
| 5585 | for fname in s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5586 | " call Decho("match(g:netrw_list_hide<".g:netrw_list_hide.'> fname<\<'.fname.'\>>)='.match(g:netrw_list_hide,'\<'.fname.'\>')." l:isk=".&l:isk,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5587 | if match(g:netrw_list_hide,'\<'.fname.'\>') != -1 |
| 5588 | " remove fname from hiding list |
| 5589 | let g:netrw_list_hide= substitute(g:netrw_list_hide,'..\<'.escape(fname,g:netrw_fname_escape).'\>..','','') |
| 5590 | let g:netrw_list_hide= substitute(g:netrw_list_hide,',,',',','g') |
| 5591 | let g:netrw_list_hide= substitute(g:netrw_list_hide,'^,\|,$','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5592 | " call Decho("unhide: g:netrw_list_hide<".g:netrw_list_hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5593 | else |
| 5594 | " append fname to hiding list |
| 5595 | if exists("g:netrw_list_hide") && g:netrw_list_hide != "" |
| 5596 | let g:netrw_list_hide= g:netrw_list_hide.',\<'.escape(fname,g:netrw_fname_escape).'\>' |
| 5597 | else |
| 5598 | let g:netrw_list_hide= '\<'.escape(fname,g:netrw_fname_escape).'\>' |
| 5599 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5600 | " call Decho("hide: g:netrw_list_hide<".g:netrw_list_hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5601 | endif |
| 5602 | endfor |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5603 | NetrwKeepj call s:NetrwUnmarkList(bufnr("%"),b:netrw_curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5604 | let g:netrw_hide= 1 |
| 5605 | |
| 5606 | else |
| 5607 | |
| 5608 | " switch between show-all/show-not-hidden/show-hidden |
| 5609 | let g:netrw_hide=(g:netrw_hide+1)%3 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5610 | exe "NetrwKeepj norm! 0" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5611 | if g:netrw_hide && g:netrw_list_hide == "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5612 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"your hiding list is empty!",49) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5613 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5614 | " call Dret("NetrwHide") |
| 5615 | return |
| 5616 | endif |
| 5617 | endif |
| 5618 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5619 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5620 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 5621 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5622 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5623 | " call Dret("NetrwHide") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 5624 | endfun |
| 5625 | |
| 5626 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5627 | " s:NetrwHideEdit: allows user to edit the file/directory hiding list {{{2 |
| 5628 | fun! s:NetrwHideEdit(islocal) |
| 5629 | " call Dfunc("NetrwHideEdit(islocal=".a:islocal.")") |
| 5630 | |
| 5631 | let ykeep= @@ |
| 5632 | " save current cursor position |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5633 | let svpos= winsaveview() |
| 5634 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5635 | |
| 5636 | " get new hiding list from user |
| 5637 | call inputsave() |
| 5638 | let newhide= input("Edit Hiding List: ",g:netrw_list_hide) |
| 5639 | call inputrestore() |
| 5640 | let g:netrw_list_hide= newhide |
| 5641 | " call Decho("new g:netrw_list_hide<".g:netrw_list_hide.">",'~'.expand("<slnum>")) |
| 5642 | |
| 5643 | " refresh the listing |
| 5644 | sil NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,"./")) |
| 5645 | |
| 5646 | " restore cursor position |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5647 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 5648 | call winrestview(svpos) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5649 | let @@= ykeep |
| 5650 | |
| 5651 | " call Dret("NetrwHideEdit") |
| 5652 | endfun |
| 5653 | |
| 5654 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5655 | " s:NetrwHidden: invoked by "gh" {{{2 |
| 5656 | fun! s:NetrwHidden(islocal) |
| 5657 | " call Dfunc("s:NetrwHidden()") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5658 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5659 | " save current position |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5660 | let svpos = winsaveview() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5661 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5662 | |
| 5663 | if g:netrw_list_hide =~ '\(^\|,\)\\(^\\|\\s\\s\\)\\zs\\.\\S\\+' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5664 | " remove .file pattern from hiding list |
| 5665 | " call Decho("remove .file pattern from hiding list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5666 | let g:netrw_list_hide= substitute(g:netrw_list_hide,'\(^\|,\)\\(^\\|\\s\\s\\)\\zs\\.\\S\\+','','') |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5667 | elseif s:Strlen(g:netrw_list_hide) >= 1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5668 | " call Decho("add .file pattern from hiding list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5669 | let g:netrw_list_hide= g:netrw_list_hide . ',\(^\|\s\s\)\zs\.\S\+' |
| 5670 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5671 | " call Decho("set .file pattern as hiding list",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5672 | let g:netrw_list_hide= '\(^\|\s\s\)\zs\.\S\+' |
| 5673 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5674 | if g:netrw_list_hide =~ '^,' |
| 5675 | let g:netrw_list_hide= strpart(g:netrw_list_hide,1) |
| 5676 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5677 | |
| 5678 | " refresh screen and return to saved position |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5679 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5680 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 5681 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5682 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5683 | " call Dret("s:NetrwHidden") |
| 5684 | endfun |
| 5685 | |
| 5686 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5687 | " s:NetrwHome: this function determines a "home" for saving bookmarks and history {{{2 |
| 5688 | fun! s:NetrwHome() |
| 5689 | if exists("g:netrw_home") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5690 | let home= expand(g:netrw_home) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5691 | else |
| 5692 | " go to vim plugin home |
| 5693 | for home in split(&rtp,',') + [''] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5694 | if isdirectory(s:NetrwFile(home)) && filewritable(s:NetrwFile(home)) | break | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5695 | let basehome= substitute(home,'[/\\]\.vim$','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5696 | if isdirectory(s:NetrwFile(basehome)) && filewritable(s:NetrwFile(basehome)) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5697 | let home= basehome."/.vim" |
| 5698 | break |
| 5699 | endif |
| 5700 | endfor |
| 5701 | if home == "" |
| 5702 | " just pick the first directory |
| 5703 | let home= substitute(&rtp,',.*$','','') |
| 5704 | endif |
| 5705 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
| 5706 | let home= substitute(home,'/','\\','g') |
| 5707 | endif |
| 5708 | endif |
| 5709 | " insure that the home directory exists |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5710 | if g:netrw_dirhistmax > 0 && !isdirectory(s:NetrwFile(home)) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5711 | " call Decho("insure that the home<".home."> directory exists") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5712 | if exists("g:netrw_mkdir") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5713 | " call Decho("call system(".g:netrw_mkdir." ".s:ShellEscape(s:NetrwFile(home)).")") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5714 | call system(g:netrw_mkdir." ".s:ShellEscape(s:NetrwFile(home))) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5715 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5716 | " call Decho("mkdir(".home.")") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 5717 | call mkdir(home) |
| 5718 | endif |
| 5719 | endif |
| 5720 | let g:netrw_home= home |
| 5721 | return home |
| 5722 | endfun |
| 5723 | |
| 5724 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5725 | " s:NetrwLeftmouse: handles the <leftmouse> when in a netrw browsing window {{{2 |
| 5726 | fun! s:NetrwLeftmouse(islocal) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5727 | if exists("s:netrwdrag") |
| 5728 | return |
| 5729 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5730 | if &ft != "netrw" |
| 5731 | return |
| 5732 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5733 | " call Dfunc("s:NetrwLeftmouse(islocal=".a:islocal.")") |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5734 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5735 | let ykeep= @@ |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5736 | " check if the status bar was clicked on instead of a file/directory name |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5737 | while getchar(0) != 0 |
| 5738 | "clear the input stream |
| 5739 | endwhile |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5740 | call feedkeys("\<LeftMouse>") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 5741 | let c = getchar() |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5742 | let mouse_lnum = v:mouse_lnum |
| 5743 | let wlastline = line('w$') |
| 5744 | let lastline = line('$') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5745 | " call Decho("v:mouse_lnum=".mouse_lnum." line(w$)=".wlastline." line($)=".lastline." v:mouse_win=".v:mouse_win." winnr#".winnr(),'~'.expand("<slnum>")) |
| 5746 | " call Decho("v:mouse_col =".v:mouse_col." col=".col(".")." wincol =".wincol()." winwidth =".winwidth(0),'~'.expand("<slnum>")) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5747 | if mouse_lnum >= wlastline + 1 || v:mouse_win != winnr() |
| 5748 | " appears to be a status bar leftmouse click |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5749 | let @@= ykeep |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5750 | " call Dret("s:NetrwLeftmouse : detected a status bar leftmouse click") |
| 5751 | return |
| 5752 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5753 | " Dec 04, 2013: following test prevents leftmouse selection/deselection of directories and files in treelist mode |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5754 | " Windows are separated by vertical separator bars - but the mouse seems to be doing what it should when dragging that bar |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5755 | " without this test when its disabled. |
| 5756 | " May 26, 2014: edit file, :Lex, resize window -- causes refresh. Reinstated a modified test. See if problems develop. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5757 | " call Decho("v:mouse_col=".v:mouse_col." col#".col('.')." virtcol#".virtcol('.')." col($)#".col("$")." virtcol($)#".virtcol("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5758 | if v:mouse_col > virtcol('.') |
| 5759 | let @@= ykeep |
| 5760 | " call Dret("s:NetrwLeftmouse : detected a vertical separator bar leftmouse click") |
| 5761 | return |
| 5762 | endif |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 5763 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5764 | if a:islocal |
| 5765 | if exists("b:netrw_curdir") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5766 | NetrwKeepj call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5767 | endif |
| 5768 | else |
| 5769 | if exists("b:netrw_curdir") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5770 | NetrwKeepj call s:NetrwBrowse(0,s:NetrwBrowseChgDir(0,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5771 | endif |
| 5772 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5773 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5774 | " call Dret("s:NetrwLeftmouse") |
| 5775 | endfun |
| 5776 | |
| 5777 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5778 | " s:NetrwCLeftmouse: used to select a file/directory for a target {{{2 |
| 5779 | fun! s:NetrwCLeftmouse(islocal) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5780 | if &ft != "netrw" |
| 5781 | return |
| 5782 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5783 | " call Dfunc("s:NetrwCLeftmouse(islocal=".a:islocal.")") |
| 5784 | call s:NetrwMarkFileTgt(a:islocal) |
| 5785 | " call Dret("s:NetrwCLeftmouse") |
| 5786 | endfun |
| 5787 | |
| 5788 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5789 | " s:NetrwServerEdit: edit file in a server gvim, usually NETRWSERVER (implements <c-r>){{{2 |
| 5790 | " a:islocal=0 : <c-r> not used, remote |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5791 | " a:islocal=1 : <c-r> not used, local |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5792 | " a:islocal=2 : <c-r> used, remote |
| 5793 | " a:islocal=3 : <c-r> used, local |
| 5794 | fun! s:NetrwServerEdit(islocal,fname) |
| 5795 | " call Dfunc("s:NetrwServerEdit(islocal=".a:islocal.",fname<".a:fname.">)") |
| 5796 | let islocal = a:islocal%2 " =0: remote =1: local |
| 5797 | let ctrlr = a:islocal >= 2 " =0: <c-r> not used =1: <c-r> used |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5798 | " call Decho("islocal=".islocal." ctrlr=".ctrlr,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5799 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5800 | if (islocal && isdirectory(s:NetrwFile(a:fname))) || (!islocal && a:fname =~ '/$') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5801 | " handle directories in the local window -- not in the remote vim server |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5802 | " user must have closed the NETRWSERVER window. Treat as normal editing from netrw. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5803 | " call Decho("handling directory in client window",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5804 | let g:netrw_browse_split= 0 |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 5805 | if exists("s:netrw_browse_split") && exists("s:netrw_browse_split_".winnr()) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5806 | let g:netrw_browse_split= s:netrw_browse_split_{winnr()} |
| 5807 | unlet s:netrw_browse_split_{winnr()} |
| 5808 | endif |
| 5809 | call s:NetrwBrowse(islocal,s:NetrwBrowseChgDir(islocal,a:fname)) |
| 5810 | " call Dret("s:NetrwServerEdit") |
| 5811 | return |
| 5812 | endif |
| 5813 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5814 | " call Decho("handling file in server window",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5815 | if has("clientserver") && executable("gvim") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5816 | " call Decho("has clientserver and gvim",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5817 | |
| 5818 | if exists("g:netrw_browse_split") && type(g:netrw_browse_split) == 3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5819 | " call Decho("g:netrw_browse_split=".string(g:netrw_browse_split),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5820 | let srvrname = g:netrw_browse_split[0] |
| 5821 | let tabnum = g:netrw_browse_split[1] |
| 5822 | let winnum = g:netrw_browse_split[2] |
| 5823 | |
| 5824 | if serverlist() !~ '\<'.srvrname.'\>' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5825 | " call Decho("server not available; ctrlr=".ctrlr,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5826 | |
| 5827 | if !ctrlr |
| 5828 | " user must have closed the server window and the user did not use <c-r>, but |
| 5829 | " used something like <cr>. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5830 | " call Decho("user must have closed server AND did not use ctrl-r",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5831 | if exists("g:netrw_browse_split") |
| 5832 | unlet g:netrw_browse_split |
| 5833 | endif |
| 5834 | let g:netrw_browse_split= 0 |
| 5835 | if exists("s:netrw_browse_split_".winnr()) |
| 5836 | let g:netrw_browse_split= s:netrw_browse_split_{winnr()} |
| 5837 | endif |
| 5838 | call s:NetrwBrowseChgDir(islocal,a:fname) |
| 5839 | " call Dret("s:NetrwServerEdit") |
| 5840 | return |
| 5841 | |
| 5842 | elseif has("win32") && executable("start") |
| 5843 | " start up remote netrw server under windows |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5844 | " call Decho("starting up gvim server<".srvrname."> for windows",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5845 | call system("start gvim --servername ".srvrname) |
| 5846 | |
| 5847 | else |
| 5848 | " start up remote netrw server under linux |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5849 | " call Decho("starting up gvim server<".srvrname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5850 | call system("gvim --servername ".srvrname) |
| 5851 | endif |
| 5852 | endif |
| 5853 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5854 | " call Decho("srvrname<".srvrname."> tabnum=".tabnum." winnum=".winnum." server-editing<".a:fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5855 | call remote_send(srvrname,":tabn ".tabnum."\<cr>") |
| 5856 | call remote_send(srvrname,":".winnum."wincmd w\<cr>") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5857 | call remote_send(srvrname,":e ".fnameescape(s:NetrwFile(a:fname))."\<cr>") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5858 | |
| 5859 | else |
| 5860 | |
| 5861 | if serverlist() !~ '\<'.g:netrw_servername.'\>' |
| 5862 | |
| 5863 | if !ctrlr |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5864 | " call Decho("server<".g:netrw_servername."> not available and ctrl-r not used",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5865 | if exists("g:netrw_browse_split") |
| 5866 | unlet g:netrw_browse_split |
| 5867 | endif |
| 5868 | let g:netrw_browse_split= 0 |
| 5869 | call s:NetrwBrowse(islocal,s:NetrwBrowseChgDir(islocal,a:fname)) |
| 5870 | " call Dret("s:NetrwServerEdit") |
| 5871 | return |
| 5872 | |
| 5873 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5874 | " call Decho("server<".g:netrw_servername."> not available but ctrl-r used",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5875 | if has("win32") && executable("start") |
| 5876 | " start up remote netrw server under windows |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5877 | " call Decho("starting up gvim server<".g:netrw_servername."> for windows",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5878 | call system("start gvim --servername ".g:netrw_servername) |
| 5879 | else |
| 5880 | " start up remote netrw server under linux |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5881 | " call Decho("starting up gvim server<".g:netrw_servername.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5882 | call system("gvim --servername ".g:netrw_servername) |
| 5883 | endif |
| 5884 | endif |
| 5885 | endif |
| 5886 | |
| 5887 | while 1 |
| 5888 | try |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5889 | " call Decho("remote-send: e ".a:fname,'~'.expand("<slnum>")) |
| 5890 | call remote_send(g:netrw_servername,":e ".fnameescape(s:NetrwFile(a:fname))."\<cr>") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5891 | break |
| 5892 | catch /^Vim\%((\a\+)\)\=:E241/ |
| 5893 | sleep 200m |
| 5894 | endtry |
| 5895 | endwhile |
| 5896 | |
| 5897 | if exists("g:netrw_browse_split") |
| 5898 | if type(g:netrw_browse_split) != 3 |
| 5899 | let s:netrw_browse_split_{winnr()}= g:netrw_browse_split |
| 5900 | endif |
| 5901 | unlet g:netrw_browse_split |
| 5902 | endif |
| 5903 | let g:netrw_browse_split= [g:netrw_servername,1,1] |
| 5904 | endif |
| 5905 | |
| 5906 | else |
| 5907 | call netrw#ErrorMsg(s:ERROR,"you need a gui-capable vim and client-server to use <ctrl-r>",98) |
| 5908 | endif |
| 5909 | |
| 5910 | " call Dret("s:NetrwServerEdit") |
| 5911 | endfun |
| 5912 | |
| 5913 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5914 | " s:NetrwSLeftmouse: marks the file under the cursor. May be dragged to select additional files {{{2 |
| 5915 | fun! s:NetrwSLeftmouse(islocal) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5916 | if &ft != "netrw" |
| 5917 | return |
| 5918 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5919 | " call Dfunc("s:NetrwSLeftmouse(islocal=".a:islocal.")") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5920 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5921 | let s:ngw= s:NetrwGetWord() |
| 5922 | call s:NetrwMarkFile(a:islocal,s:ngw) |
| 5923 | |
| 5924 | " call Dret("s:NetrwSLeftmouse") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5925 | endfun |
| 5926 | |
| 5927 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5928 | " s:NetrwSLeftdrag: invoked via a shift-leftmouse and dragging {{{2 |
| 5929 | " Used to mark multiple files. |
| 5930 | fun! s:NetrwSLeftdrag(islocal) |
| 5931 | " call Dfunc("s:NetrwSLeftdrag(islocal=".a:islocal.")") |
| 5932 | if !exists("s:netrwdrag") |
| 5933 | let s:netrwdrag = winnr() |
| 5934 | if a:islocal |
| 5935 | nno <silent> <s-leftrelease> <leftmouse>:<c-u>call <SID>NetrwSLeftrelease(1)<cr> |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5936 | else |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5937 | nno <silent> <s-leftrelease> <leftmouse>:<c-u>call <SID>NetrwSLeftrelease(0)<cr> |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5938 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5939 | endif |
| 5940 | let ngw = s:NetrwGetWord() |
| 5941 | if !exists("s:ngw") || s:ngw != ngw |
| 5942 | call s:NetrwMarkFile(a:islocal,ngw) |
| 5943 | endif |
| 5944 | let s:ngw= ngw |
| 5945 | " call Dret("s:NetrwSLeftdrag : s:netrwdrag=".s:netrwdrag." buf#".bufnr("%")) |
| 5946 | endfun |
| 5947 | |
| 5948 | " --------------------------------------------------------------------- |
| 5949 | " s:NetrwSLeftrelease: terminates shift-leftmouse dragging {{{2 |
| 5950 | fun! s:NetrwSLeftrelease(islocal) |
| 5951 | " call Dfunc("s:NetrwSLeftrelease(islocal=".a:islocal.") s:netrwdrag=".s:netrwdrag." buf#".bufnr("%")) |
| 5952 | if exists("s:netrwdrag") |
| 5953 | nunmap <s-leftrelease> |
| 5954 | let ngw = s:NetrwGetWord() |
| 5955 | if !exists("s:ngw") || s:ngw != ngw |
| 5956 | call s:NetrwMarkFile(a:islocal,ngw) |
| 5957 | endif |
| 5958 | if exists("s:ngw") |
| 5959 | unlet s:ngw |
| 5960 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5961 | unlet s:netrwdrag |
| 5962 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 5963 | " call Dret("s:NetrwSLeftrelease") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 5964 | endfun |
| 5965 | |
| 5966 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5967 | " s:NetrwListHide: uses [range]g~...~d to delete files that match comma {{{2 |
| 5968 | " separated patterns given in g:netrw_list_hide |
| 5969 | fun! s:NetrwListHide() |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5970 | " call Dfunc("s:NetrwListHide() g:netrw_hide=".g:netrw_hide." g:netrw_list_hide<".g:netrw_list_hide.">") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5971 | " call Decho("initial: ".string(getline(w:netrw_bannercnt,'$'))) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 5972 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5973 | |
| 5974 | " find a character not in the "hide" string to use as a separator for :g and :v commands |
| 5975 | " How-it-works: take the hiding command, convert it into a range. Duplicate |
| 5976 | " characters don't matter. Remove all such characters from the '/~...90' |
| 5977 | " string. Use the first character left as a separator character. |
| 5978 | let listhide= g:netrw_list_hide |
| 5979 | let sep = strpart(substitute('/~@#$%^&*{};:,<.>?|1234567890','['.escape(listhide,'-]^\').']','','ge'),1,1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 5980 | " call Decho("sep=".sep,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5981 | |
| 5982 | while listhide != "" |
| 5983 | if listhide =~ ',' |
| 5984 | let hide = substitute(listhide,',.*$','','e') |
| 5985 | let listhide = substitute(listhide,'^.\{-},\(.*\)$','\1','e') |
| 5986 | else |
| 5987 | let hide = listhide |
| 5988 | let listhide = "" |
| 5989 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5990 | " call Decho("hide<".hide."> listhide<".listhide.'>','~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5991 | |
| 5992 | " Prune the list by hiding any files which match |
| 5993 | if g:netrw_hide == 1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5994 | " call Decho("..hiding<".hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5995 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$g'.sep.hide.sep.'d' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5996 | elseif g:netrw_hide == 2 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 5997 | " call Decho("..showing<".hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 5998 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$g'.sep.hide.sep.'s@^@ /-KEEP-/ @' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 5999 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6000 | " call Decho("..result: ".string(getline(w:netrw_bannercnt,'$')),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6001 | endwhile |
| 6002 | if g:netrw_hide == 2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6003 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$v@^ /-KEEP-/ @d' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6004 | " call Decho("..v KEEP: ".string(getline(w:netrw_bannercnt,'$')),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6005 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s@^\%( /-KEEP-/ \)\+@@e' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6006 | " call Decho("..g KEEP: ".string(getline(w:netrw_bannercnt,'$')),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6007 | endif |
| 6008 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 6009 | " remove any blank lines that have somehow remained. |
| 6010 | " This seems to happen under Windows. |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6011 | exe 'sil! NetrwKeepj 1,$g@^\s*$@d' |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 6012 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6013 | let @@= ykeep |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6014 | " call Dret("s:NetrwListHide") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6015 | endfun |
| 6016 | |
| 6017 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6018 | " s:NetrwMakeDir: this function makes a directory (both local and remote) {{{2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6019 | " implements the "d" mapping. |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6020 | fun! s:NetrwMakeDir(usrhost) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6021 | " call Dfunc("s:NetrwMakeDir(usrhost<".a:usrhost.">)") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6022 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6023 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6024 | " get name of new directory from user. A bare <CR> will skip. |
| 6025 | " if its currently a directory, also request will be skipped, but with |
| 6026 | " a message. |
| 6027 | call inputsave() |
| 6028 | let newdirname= input("Please give directory name: ") |
| 6029 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6030 | " call Decho("newdirname<".newdirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6031 | |
| 6032 | if newdirname == "" |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6033 | let @@= ykeep |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6034 | " call Dret("s:NetrwMakeDir : user aborted with bare <cr>") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6035 | return |
| 6036 | endif |
| 6037 | |
| 6038 | if a:usrhost == "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6039 | " call Decho("local mkdir",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6040 | |
| 6041 | " Local mkdir: |
| 6042 | " sanity checks |
| 6043 | let fullnewdir= b:netrw_curdir.'/'.newdirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6044 | " call Decho("fullnewdir<".fullnewdir.">",'~'.expand("<slnum>")) |
| 6045 | if isdirectory(s:NetrwFile(fullnewdir)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6046 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6047 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"<".newdirname."> is already a directory!",24) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6048 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6049 | let @@= ykeep |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6050 | " call Dret("s:NetrwMakeDir : directory<".newdirname."> exists previously") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6051 | return |
| 6052 | endif |
| 6053 | if s:FileReadable(fullnewdir) |
| 6054 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6055 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"<".newdirname."> is already a file!",25) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6056 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6057 | let @@= ykeep |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6058 | " call Dret("s:NetrwMakeDir : file<".newdirname."> exists previously") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6059 | return |
| 6060 | endif |
| 6061 | |
| 6062 | " requested new local directory is neither a pre-existing file or |
| 6063 | " directory, so make it! |
| 6064 | if exists("*mkdir") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 6065 | if has("unix") |
| 6066 | call mkdir(fullnewdir,"p",xor(0777, system("umask"))) |
| 6067 | else |
| 6068 | call mkdir(fullnewdir,"p") |
| 6069 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6070 | else |
| 6071 | let netrw_origdir= s:NetrwGetcwd(1) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6072 | if s:NetrwLcd(b:netrw_curdir) |
| 6073 | " call Dret("s:NetrwMakeDir : lcd failure") |
| 6074 | return |
| 6075 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6076 | " call Decho("netrw_origdir<".netrw_origdir.">: lcd b:netrw_curdir<".fnameescape(b:netrw_curdir).">",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6077 | call s:NetrwExe("sil! !".g:netrw_localmkdir.g:netrw_localmkdiropt.' '.s:ShellEscape(newdirname,1)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6078 | if v:shell_error != 0 |
| 6079 | let @@= ykeep |
| 6080 | call netrw#ErrorMsg(s:ERROR,"consider setting g:netrw_localmkdir<".g:netrw_localmkdir."> to something that works",80) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6081 | " call Dret("s:NetrwMakeDir : failed: sil! !".g:netrw_localmkdir.' '.s:ShellEscape(newdirname,1)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6082 | return |
| 6083 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6084 | if !g:netrw_keepdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6085 | " call Decho("restoring netrw_origdir since g:netrw_keepdir=".g:netrw_keepdir,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6086 | if s:NetrwLcd(netrw_origdir) |
| 6087 | " call Dret("s:NetrwBrowse : lcd failure") |
| 6088 | return |
| 6089 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6090 | endif |
| 6091 | endif |
| 6092 | |
| 6093 | if v:shell_error == 0 |
| 6094 | " refresh listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6095 | " call Decho("refresh listing",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6096 | let svpos= winsaveview() |
| 6097 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6098 | call s:NetrwRefresh(1,s:NetrwBrowseChgDir(1,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6099 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6100 | call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6101 | elseif !exists("g:netrw_quiet") |
| 6102 | call netrw#ErrorMsg(s:ERROR,"unable to make directory<".newdirname.">",26) |
| 6103 | endif |
| 6104 | " redraw! |
| 6105 | |
| 6106 | elseif !exists("b:netrw_method") || b:netrw_method == 4 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6107 | " Remote mkdir: using ssh |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6108 | " call Decho("remote mkdir",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6109 | let mkdircmd = s:MakeSshCmd(g:netrw_mkdir_cmd) |
| 6110 | let newdirname= substitute(b:netrw_curdir,'^\%(.\{-}/\)\{3}\(.*\)$','\1','').newdirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6111 | call s:NetrwExe("sil! !".mkdircmd." ".s:ShellEscape(newdirname,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6112 | if v:shell_error == 0 |
| 6113 | " refresh listing |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6114 | let svpos= winsaveview() |
| 6115 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6116 | NetrwKeepj call s:NetrwRefresh(0,s:NetrwBrowseChgDir(0,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6117 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6118 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6119 | elseif !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6120 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"unable to make directory<".newdirname.">",27) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6121 | endif |
| 6122 | " redraw! |
| 6123 | |
| 6124 | elseif b:netrw_method == 2 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6125 | " Remote mkdir: using ftp+.netrc |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6126 | let svpos= winsaveview() |
| 6127 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6128 | " call Decho("b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6129 | if exists("b:netrw_fname") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6130 | " call Decho("b:netrw_fname<".b:netrw_fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6131 | let remotepath= b:netrw_fname |
| 6132 | else |
| 6133 | let remotepath= "" |
| 6134 | endif |
| 6135 | call s:NetrwRemoteFtpCmd(remotepath,g:netrw_remote_mkdir.' "'.newdirname.'"') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6136 | NetrwKeepj call s:NetrwRefresh(0,s:NetrwBrowseChgDir(0,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6137 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6138 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6139 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6140 | elseif b:netrw_method == 3 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6141 | " Remote mkdir: using ftp + machine, id, passwd, and fname (ie. no .netrc) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6142 | let svpos= winsaveview() |
| 6143 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6144 | " call Decho("b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6145 | if exists("b:netrw_fname") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6146 | " call Decho("b:netrw_fname<".b:netrw_fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6147 | let remotepath= b:netrw_fname |
| 6148 | else |
| 6149 | let remotepath= "" |
| 6150 | endif |
| 6151 | call s:NetrwRemoteFtpCmd(remotepath,g:netrw_remote_mkdir.' "'.newdirname.'"') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6152 | NetrwKeepj call s:NetrwRefresh(0,s:NetrwBrowseChgDir(0,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6153 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6154 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6155 | endif |
| 6156 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6157 | let @@= ykeep |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6158 | " call Dret("s:NetrwMakeDir") |
| 6159 | endfun |
| 6160 | |
| 6161 | " --------------------------------------------------------------------- |
| 6162 | " s:TreeSqueezeDir: allows a shift-cr (gvim only) to squeeze the current tree-listing directory {{{2 |
| 6163 | fun! s:TreeSqueezeDir(islocal) |
| 6164 | " call Dfunc("s:TreeSqueezeDir(islocal=".a:islocal.")") |
| 6165 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") |
| 6166 | " its a tree-listing style |
| 6167 | let curdepth = substitute(getline('.'),'^\(\%('.s:treedepthstring.'\)*\)[^'.s:treedepthstring.'].\{-}$','\1','e') |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6168 | let stopline = (exists("w:netrw_bannercnt")? (w:netrw_bannercnt + 1) : 1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6169 | let depth = strchars(substitute(curdepth,' ','','g')) |
| 6170 | let srch = -1 |
| 6171 | " call Decho("curdepth<".curdepth.'>','~'.expand("<slnum>")) |
| 6172 | " call Decho("depth =".depth,'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6173 | " call Decho("stopline#".stopline,'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6174 | " call Decho("curline#".line(".")."<".getline('.').'>','~'.expand("<slnum>")) |
| 6175 | if depth >= 2 |
| 6176 | NetrwKeepj norm! 0 |
| 6177 | let curdepthm1= substitute(curdepth,'^'.s:treedepthstring,'','') |
| 6178 | let srch = search('^'.curdepthm1.'\%('.s:treedepthstring.'\)\@!','bW',stopline) |
| 6179 | " call Decho("curdepthm1<".curdepthm1.'>','~'.expand("<slnum>")) |
| 6180 | " call Decho("case depth>=2: srch<".srch.'>','~'.expand("<slnum>")) |
| 6181 | elseif depth == 1 |
| 6182 | NetrwKeepj norm! 0 |
| 6183 | let treedepthchr= substitute(s:treedepthstring,' ','','') |
| 6184 | let srch = search('^[^'.treedepthchr.']','bW',stopline) |
| 6185 | " call Decho("case depth==1: srch<".srch.'>','~'.expand("<slnum>")) |
| 6186 | endif |
| 6187 | if srch > 0 |
| 6188 | " call Decho("squeezing at line#".line(".").": ".getline('.'),'~'.expand("<slnum>")) |
| 6189 | call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,s:NetrwGetWord())) |
| 6190 | exe srch |
| 6191 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6192 | endif |
| 6193 | " call Dret("s:TreeSqueezeDir") |
| 6194 | endfun |
| 6195 | |
| 6196 | " --------------------------------------------------------------------- |
| 6197 | " s:NetrwMaps: {{{2 |
| 6198 | fun! s:NetrwMaps(islocal) |
| 6199 | " call Dfunc("s:NetrwMaps(islocal=".a:islocal.") b:netrw_curdir<".b:netrw_curdir.">") |
| 6200 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6201 | " mouse <Plug> maps: {{{3 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6202 | if g:netrw_mousemaps && g:netrw_retmap |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6203 | " call Decho("set up Rexplore 2-leftmouse",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6204 | if !hasmapto("<Plug>NetrwReturn") |
| 6205 | if maparg("<2-leftmouse>","n") == "" || maparg("<2-leftmouse>","n") =~ '^-$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6206 | " call Decho("making map for 2-leftmouse",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6207 | nmap <unique> <silent> <2-leftmouse> <Plug>NetrwReturn |
| 6208 | elseif maparg("<c-leftmouse>","n") == "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6209 | " call Decho("making map for c-leftmouse",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6210 | nmap <unique> <silent> <c-leftmouse> <Plug>NetrwReturn |
| 6211 | endif |
| 6212 | endif |
| 6213 | nno <silent> <Plug>NetrwReturn :Rexplore<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6214 | " call Decho("made <Plug>NetrwReturn map",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6215 | endif |
| 6216 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6217 | " generate default <Plug> maps {{{3 |
| 6218 | if !hasmapto('<Plug>NetrwHide') |nmap <buffer> <silent> <nowait> a <Plug>NetrwHide_a|endif |
| 6219 | if !hasmapto('<Plug>NetrwBrowseUpDir') |nmap <buffer> <silent> <nowait> - <Plug>NetrwBrowseUpDir |endif |
| 6220 | if !hasmapto('<Plug>NetrwOpenFile') |nmap <buffer> <silent> <nowait> % <Plug>NetrwOpenFile|endif |
| 6221 | if !hasmapto('<Plug>NetrwBadd_cb') |nmap <buffer> <silent> <nowait> cb <Plug>NetrwBadd_cb|endif |
| 6222 | if !hasmapto('<Plug>NetrwBadd_cB') |nmap <buffer> <silent> <nowait> cB <Plug>NetrwBadd_cB|endif |
| 6223 | if !hasmapto('<Plug>NetrwLcd') |nmap <buffer> <silent> <nowait> cd <Plug>NetrwLcd|endif |
| 6224 | if !hasmapto('<Plug>NetrwSetChgwin') |nmap <buffer> <silent> <nowait> C <Plug>NetrwSetChgwin|endif |
| 6225 | if !hasmapto('<Plug>NetrwRefresh') |nmap <buffer> <silent> <nowait> <c-l> <Plug>NetrwRefresh|endif |
| 6226 | if !hasmapto('<Plug>NetrwLocalBrowseCheck') |nmap <buffer> <silent> <nowait> <cr> <Plug>NetrwLocalBrowseCheck|endif |
| 6227 | if !hasmapto('<Plug>NetrwServerEdit') |nmap <buffer> <silent> <nowait> <c-r> <Plug>NetrwServerEdit|endif |
| 6228 | if !hasmapto('<Plug>NetrwMakeDir') |nmap <buffer> <silent> <nowait> d <Plug>NetrwMakeDir|endif |
| 6229 | if !hasmapto('<Plug>NetrwBookHistHandler_gb')|nmap <buffer> <silent> <nowait> gb <Plug>NetrwBookHistHandler_gb|endif |
| 6230 | " --------------------------------------------------------------------- |
| 6231 | " if !hasmapto('<Plug>NetrwForceChgDir') |nmap <buffer> <silent> <nowait> gd <Plug>NetrwForceChgDir|endif |
| 6232 | " if !hasmapto('<Plug>NetrwForceFile') |nmap <buffer> <silent> <nowait> gf <Plug>NetrwForceFile|endif |
| 6233 | " if !hasmapto('<Plug>NetrwHidden') |nmap <buffer> <silent> <nowait> gh <Plug>NetrwHidden|endif |
| 6234 | " if !hasmapto('<Plug>NetrwSetTreetop') |nmap <buffer> <silent> <nowait> gn <Plug>NetrwSetTreetop|endif |
| 6235 | " if !hasmapto('<Plug>NetrwChgPerm') |nmap <buffer> <silent> <nowait> gp <Plug>NetrwChgPerm|endif |
| 6236 | " if !hasmapto('<Plug>NetrwBannerCtrl') |nmap <buffer> <silent> <nowait> I <Plug>NetrwBannerCtrl|endif |
| 6237 | " if !hasmapto('<Plug>NetrwListStyle') |nmap <buffer> <silent> <nowait> i <Plug>NetrwListStyle|endif |
| 6238 | " if !hasmapto('<Plug>NetrwMarkMoveMF2Arglist')|nmap <buffer> <silent> <nowait> ma <Plug>NetrwMarkMoveMF2Arglist|endif |
| 6239 | " if !hasmapto('<Plug>NetrwMarkMoveArglist2MF')|nmap <buffer> <silent> <nowait> mA <Plug>NetrwMarkMoveArglist2MF|endif |
| 6240 | " if !hasmapto('<Plug>NetrwBookHistHandler_mA')|nmap <buffer> <silent> <nowait> mb <Plug>NetrwBookHistHandler_mA|endif |
| 6241 | " if !hasmapto('<Plug>NetrwBookHistHandler_mB')|nmap <buffer> <silent> <nowait> mB <Plug>NetrwBookHistHandler_mB|endif |
| 6242 | " if !hasmapto('<Plug>NetrwMarkFileCopy') |nmap <buffer> <silent> <nowait> mc <Plug>NetrwMarkFileCopy|endif |
| 6243 | " if !hasmapto('<Plug>NetrwMarkFileDiff') |nmap <buffer> <silent> <nowait> md <Plug>NetrwMarkFileDiff|endif |
| 6244 | " if !hasmapto('<Plug>NetrwMarkFileEdit') |nmap <buffer> <silent> <nowait> me <Plug>NetrwMarkFileEdit|endif |
| 6245 | " if !hasmapto('<Plug>NetrwMarkFile') |nmap <buffer> <silent> <nowait> mf <Plug>NetrwMarkFile|endif |
| 6246 | " if !hasmapto('<Plug>NetrwUnmarkList') |nmap <buffer> <silent> <nowait> mF <Plug>NetrwUnmarkList|endif |
| 6247 | " if !hasmapto('<Plug>NetrwMarkFileGrep') |nmap <buffer> <silent> <nowait> mg <Plug>NetrwMarkFileGrep|endif |
| 6248 | " if !hasmapto('<Plug>NetrwMarkHideSfx') |nmap <buffer> <silent> <nowait> mh <Plug>NetrwMarkHideSfx|endif |
| 6249 | " if !hasmapto('<Plug>NetrwMarkFileMove') |nmap <buffer> <silent> <nowait> mm <Plug>NetrwMarkFileMove|endif |
| 6250 | " if !hasmapto('<Plug>NetrwMarkFilePrint') |nmap <buffer> <silent> <nowait> mp <Plug>NetrwMarkFilePrint|endif |
| 6251 | " if !hasmapto('<Plug>NetrwMarkFileRegexp') |nmap <buffer> <silent> <nowait> mr <Plug>NetrwMarkFileRegexp|endif |
| 6252 | " if !hasmapto('<Plug>NetrwMarkFileSource') |nmap <buffer> <silent> <nowait> ms <Plug>NetrwMarkFileSource|endif |
| 6253 | " if !hasmapto('<Plug>NetrwMarkFileTag') |nmap <buffer> <silent> <nowait> mT <Plug>NetrwMarkFileTag|endif |
| 6254 | " if !hasmapto('<Plug>NetrwMarkFileTgt') |nmap <buffer> <silent> <nowait> mt <Plug>NetrwMarkFileTgt|endif |
| 6255 | " if !hasmapto('<Plug>NetrwUnMarkFile') |nmap <buffer> <silent> <nowait> mu <Plug>NetrwUnMarkFile|endif |
| 6256 | " if !hasmapto('<Plug>NetrwMarkFileVimCmd') |nmap <buffer> <silent> <nowait> mv <Plug>NetrwMarkFileVimCmd|endif |
| 6257 | " if !hasmapto('<Plug>NetrwMarkFileExe_mx') |nmap <buffer> <silent> <nowait> mx <Plug>NetrwMarkFileExe_mx|endif |
| 6258 | " if !hasmapto('<Plug>NetrwMarkFileExe_mX') |nmap <buffer> <silent> <nowait> mX <Plug>NetrwMarkFileExe_mX|endif |
| 6259 | " if !hasmapto('<Plug>NetrwMarkFileCompress') |nmap <buffer> <silent> <nowait> mz <Plug>NetrwMarkFileCompress|endif |
| 6260 | " if !hasmapto('<Plug>NetrwObtain') |nmap <buffer> <silent> <nowait> O <Plug>NetrwObtain|endif |
| 6261 | " if !hasmapto('<Plug>NetrwSplit_o') |nmap <buffer> <silent> <nowait> o <Plug>NetrwSplit_o|endif |
| 6262 | " if !hasmapto('<Plug>NetrwPreview') |nmap <buffer> <silent> <nowait> p <Plug>NetrwPreview|endif |
| 6263 | " if !hasmapto('<Plug>NetrwPrevWinOpen') |nmap <buffer> <silent> <nowait> P <Plug>NetrwPrevWinOpen|endif |
| 6264 | " if !hasmapto('<Plug>NetrwBookHistHandler_qb')|nmap <buffer> <silent> <nowait> qb <Plug>NetrwBookHistHandler_qb|endif |
| 6265 | " if !hasmapto('<Plug>NetrwFileInfo') |nmap <buffer> <silent> <nowait> qf <Plug>NetrwFileInfo|endif |
| 6266 | " if !hasmapto('<Plug>NetrwMarkFileQFEL_qF') |nmap <buffer> <silent> <nowait> qF <Plug>NetrwMarkFileQFEL_qF|endif |
| 6267 | " if !hasmapto('<Plug>NetrwMarkFileQFEL_qL') |nmap <buffer> <silent> <nowait> qL <Plug>NetrwMarkFileQFEL_qL|endif |
| 6268 | " if !hasmapto('<Plug>NetrwSortStyle') |nmap <buffer> <silent> <nowait> s <Plug>NetrwSortStyle|endif |
| 6269 | " if !hasmapto('<Plug>NetSortSequence') |nmap <buffer> <silent> <nowait> S <Plug>NetSortSequence|endif |
| 6270 | " if !hasmapto('<Plug>NetrwSetTgt_Tb') |nmap <buffer> <silent> <nowait> Tb <Plug>NetrwSetTgt_Tb|endif |
| 6271 | " if !hasmapto('<Plug>NetrwSetTgt_Th') |nmap <buffer> <silent> <nowait> Th <Plug>NetrwSetTgt_Th|endif |
| 6272 | " if !hasmapto('<Plug>NetrwSplit_t') |nmap <buffer> <silent> <nowait> t <Plug>NetrwSplit_t|endif |
| 6273 | " if !hasmapto('<Plug>NetrwBookHistHandler_u') |nmap <buffer> <silent> <nowait> u <Plug>NetrwBookHistHandler_u|endif |
| 6274 | " if !hasmapto('<Plug>NetrwBookHistHandler_U') |nmap <buffer> <silent> <nowait> U <Plug>NetrwBookHistHandler_U|endif |
| 6275 | " if !hasmapto('<Plug>NetrwSplit_v') |nmap <buffer> <silent> <nowait> v <Plug>NetrwSplit_v|endif |
| 6276 | " if !hasmapto('<Plug>NetrwBrowseX') |nmap <buffer> <silent> <nowait> x <Plug>NetrwBrowseX|endif |
| 6277 | " if !hasmapto('<Plug>NetrwLocalExecute') |nmap <buffer> <silent> <nowait> X <Plug>NetrwLocalExecute|endif |
| 6278 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6279 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6280 | " call Decho("make local maps",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6281 | " local normal-mode maps {{{3 |
| 6282 | nnoremap <buffer> <silent> <Plug>NetrwHide_a :<c-u>call <SID>NetrwHide(1)<cr> |
| 6283 | nnoremap <buffer> <silent> <Plug>NetrwBrowseUpDir :<c-u>call <SID>NetrwBrowseUpDir(1)<cr> |
| 6284 | nnoremap <buffer> <silent> <Plug>NetrwOpenFile :<c-u>call <SID>NetrwOpenFile(1)<cr> |
| 6285 | nnoremap <buffer> <silent> <Plug>NetrwBadd_cb :<c-u>call <SID>NetrwBadd(1,0)<cr> |
| 6286 | nnoremap <buffer> <silent> <Plug>NetrwBadd_cB :<c-u>call <SID>NetrwBadd(1,1)<cr> |
| 6287 | nnoremap <buffer> <silent> <Plug>NetrwLcd :<c-u>call <SID>NetrwLcd(b:netrw_curdir)<cr> |
| 6288 | nnoremap <buffer> <silent> <Plug>NetrwSetChgwin :<c-u>call <SID>NetrwSetChgwin()<cr> |
| 6289 | nnoremap <buffer> <silent> <Plug>NetrwLocalBrowseCheck :<c-u>call netrw#LocalBrowseCheck(<SID>NetrwBrowseChgDir(1,<SID>NetrwGetWord()))<cr> |
| 6290 | nnoremap <buffer> <silent> <Plug>NetrwServerEdit :<c-u>call <SID>NetrwServerEdit(3,<SID>NetrwGetWord())<cr> |
| 6291 | nnoremap <buffer> <silent> <Plug>NetrwMakeDir :<c-u>call <SID>NetrwMakeDir("")<cr> |
| 6292 | nnoremap <buffer> <silent> <Plug>NetrwBookHistHandler_gb :<c-u>call <SID>NetrwBookHistHandler(1,b:netrw_curdir)<cr> |
| 6293 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6294 | nnoremap <buffer> <silent> <nowait> gd :<c-u>call <SID>NetrwForceChgDir(1,<SID>NetrwGetWord())<cr> |
| 6295 | nnoremap <buffer> <silent> <nowait> gf :<c-u>call <SID>NetrwForceFile(1,<SID>NetrwGetWord())<cr> |
| 6296 | nnoremap <buffer> <silent> <nowait> gh :<c-u>call <SID>NetrwHidden(1)<cr> |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6297 | nnoremap <buffer> <silent> <nowait> gn :<c-u>call netrw#SetTreetop(0,<SID>NetrwGetWord())<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6298 | nnoremap <buffer> <silent> <nowait> gp :<c-u>call <SID>NetrwChgPerm(1,b:netrw_curdir)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6299 | nnoremap <buffer> <silent> <nowait> I :<c-u>call <SID>NetrwBannerCtrl(1)<cr> |
| 6300 | nnoremap <buffer> <silent> <nowait> i :<c-u>call <SID>NetrwListStyle(1)<cr> |
| 6301 | nnoremap <buffer> <silent> <nowait> ma :<c-u>call <SID>NetrwMarkFileArgList(1,0)<cr> |
| 6302 | nnoremap <buffer> <silent> <nowait> mA :<c-u>call <SID>NetrwMarkFileArgList(1,1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6303 | nnoremap <buffer> <silent> <nowait> mb :<c-u>call <SID>NetrwBookHistHandler(0,b:netrw_curdir)<cr> |
| 6304 | nnoremap <buffer> <silent> <nowait> mB :<c-u>call <SID>NetrwBookHistHandler(6,b:netrw_curdir)<cr> |
| 6305 | nnoremap <buffer> <silent> <nowait> mc :<c-u>call <SID>NetrwMarkFileCopy(1)<cr> |
| 6306 | nnoremap <buffer> <silent> <nowait> md :<c-u>call <SID>NetrwMarkFileDiff(1)<cr> |
| 6307 | nnoremap <buffer> <silent> <nowait> me :<c-u>call <SID>NetrwMarkFileEdit(1)<cr> |
| 6308 | nnoremap <buffer> <silent> <nowait> mf :<c-u>call <SID>NetrwMarkFile(1,<SID>NetrwGetWord())<cr> |
| 6309 | nnoremap <buffer> <silent> <nowait> mF :<c-u>call <SID>NetrwUnmarkList(bufnr("%"),b:netrw_curdir)<cr> |
| 6310 | nnoremap <buffer> <silent> <nowait> mg :<c-u>call <SID>NetrwMarkFileGrep(1)<cr> |
| 6311 | nnoremap <buffer> <silent> <nowait> mh :<c-u>call <SID>NetrwMarkHideSfx(1)<cr> |
| 6312 | nnoremap <buffer> <silent> <nowait> mm :<c-u>call <SID>NetrwMarkFileMove(1)<cr> |
| 6313 | nnoremap <buffer> <silent> <nowait> mp :<c-u>call <SID>NetrwMarkFilePrint(1)<cr> |
| 6314 | nnoremap <buffer> <silent> <nowait> mr :<c-u>call <SID>NetrwMarkFileRegexp(1)<cr> |
| 6315 | nnoremap <buffer> <silent> <nowait> ms :<c-u>call <SID>NetrwMarkFileSource(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6316 | nnoremap <buffer> <silent> <nowait> mT :<c-u>call <SID>NetrwMarkFileTag(1)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6317 | nnoremap <buffer> <silent> <nowait> mt :<c-u>call <SID>NetrwMarkFileTgt(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6318 | nnoremap <buffer> <silent> <nowait> mu :<c-u>call <SID>NetrwUnMarkFile(1)<cr> |
| 6319 | nnoremap <buffer> <silent> <nowait> mv :<c-u>call <SID>NetrwMarkFileVimCmd(1)<cr> |
| 6320 | nnoremap <buffer> <silent> <nowait> mx :<c-u>call <SID>NetrwMarkFileExe(1,0)<cr> |
| 6321 | nnoremap <buffer> <silent> <nowait> mX :<c-u>call <SID>NetrwMarkFileExe(1,1)<cr> |
| 6322 | nnoremap <buffer> <silent> <nowait> mz :<c-u>call <SID>NetrwMarkFileCompress(1)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6323 | nnoremap <buffer> <silent> <nowait> O :<c-u>call <SID>NetrwObtain(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6324 | nnoremap <buffer> <silent> <nowait> o :call <SID>NetrwSplit(3)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6325 | nnoremap <buffer> <silent> <nowait> p :<c-u>call <SID>NetrwPreview(<SID>NetrwBrowseChgDir(1,<SID>NetrwGetWord(),1))<cr> |
| 6326 | nnoremap <buffer> <silent> <nowait> P :<c-u>call <SID>NetrwPrevWinOpen(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6327 | nnoremap <buffer> <silent> <nowait> qb :<c-u>call <SID>NetrwBookHistHandler(2,b:netrw_curdir)<cr> |
| 6328 | nnoremap <buffer> <silent> <nowait> qf :<c-u>call <SID>NetrwFileInfo(1,<SID>NetrwGetWord())<cr> |
| 6329 | nnoremap <buffer> <silent> <nowait> qF :<c-u>call <SID>NetrwMarkFileQFEL(1,getqflist())<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6330 | nnoremap <buffer> <silent> <nowait> qL :<c-u>call <SID>NetrwMarkFileQFEL(1,getloclist(v:count))<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6331 | nnoremap <buffer> <silent> <nowait> s :call <SID>NetrwSortStyle(1)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6332 | nnoremap <buffer> <silent> <nowait> S :<c-u>call <SID>NetSortSequence(1)<cr> |
| 6333 | nnoremap <buffer> <silent> <nowait> Tb :<c-u>call <SID>NetrwSetTgt(1,'b',v:count1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6334 | nnoremap <buffer> <silent> <nowait> t :call <SID>NetrwSplit(4)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6335 | nnoremap <buffer> <silent> <nowait> Th :<c-u>call <SID>NetrwSetTgt(1,'h',v:count)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6336 | nnoremap <buffer> <silent> <nowait> u :<c-u>call <SID>NetrwBookHistHandler(4,expand("%"))<cr> |
| 6337 | nnoremap <buffer> <silent> <nowait> U :<c-u>call <SID>NetrwBookHistHandler(5,expand("%"))<cr> |
| 6338 | nnoremap <buffer> <silent> <nowait> v :call <SID>NetrwSplit(5)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6339 | nnoremap <buffer> <silent> <nowait> x :<c-u>call netrw#BrowseX(<SID>NetrwBrowseChgDir(1,<SID>NetrwGetWord(),0),0)"<cr> |
| 6340 | nnoremap <buffer> <silent> <nowait> X :<c-u>call <SID>NetrwLocalExecute(expand("<cword>"))"<cr> |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6341 | |
| 6342 | nnoremap <buffer> <silent> <nowait> r :<c-u>let g:netrw_sort_direction= (g:netrw_sort_direction =~# 'n')? 'r' : 'n'<bar>exe "norm! 0"<bar>call <SID>NetrwRefresh(1,<SID>NetrwBrowseChgDir(1,'./'))<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6343 | if !hasmapto('<Plug>NetrwHideEdit') |
| 6344 | nmap <buffer> <unique> <c-h> <Plug>NetrwHideEdit |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6345 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6346 | nnoremap <buffer> <silent> <Plug>NetrwHideEdit :call <SID>NetrwHideEdit(1)<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6347 | if !hasmapto('<Plug>NetrwRefresh') |
| 6348 | nmap <buffer> <unique> <c-l> <Plug>NetrwRefresh |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6349 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6350 | nnoremap <buffer> <silent> <Plug>NetrwRefresh <c-l>:call <SID>NetrwRefresh(1,<SID>NetrwBrowseChgDir(1,(w:netrw_liststyle == 3)? w:netrw_treetop : './'))<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6351 | if s:didstarstar || !mapcheck("<s-down>","n") |
| 6352 | nnoremap <buffer> <silent> <s-down> :Nexplore<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6353 | endif |
| 6354 | if s:didstarstar || !mapcheck("<s-up>","n") |
| 6355 | nnoremap <buffer> <silent> <s-up> :Pexplore<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6356 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6357 | if !hasmapto('<Plug>NetrwTreeSqueeze') |
| 6358 | nmap <buffer> <silent> <nowait> <s-cr> <Plug>NetrwTreeSqueeze |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6359 | endif |
| 6360 | nnoremap <buffer> <silent> <Plug>NetrwTreeSqueeze :call <SID>TreeSqueezeDir(1)<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6361 | let mapsafecurdir = escape(b:netrw_curdir, s:netrw_map_escape) |
| 6362 | if g:netrw_mousemaps == 1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6363 | nmap <buffer> <leftmouse> <Plug>NetrwLeftmouse |
| 6364 | nmap <buffer> <c-leftmouse> <Plug>NetrwCLeftmouse |
| 6365 | nmap <buffer> <middlemouse> <Plug>NetrwMiddlemouse |
| 6366 | nmap <buffer> <s-leftmouse> <Plug>NetrwSLeftmouse |
| 6367 | nmap <buffer> <s-leftdrag> <Plug>NetrwSLeftdrag |
| 6368 | nmap <buffer> <2-leftmouse> <Plug>Netrw2Leftmouse |
| 6369 | imap <buffer> <leftmouse> <Plug>ILeftmouse |
| 6370 | imap <buffer> <middlemouse> <Plug>IMiddlemouse |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6371 | nno <buffer> <silent> <Plug>NetrwLeftmouse <leftmouse>:call <SID>NetrwLeftmouse(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6372 | nno <buffer> <silent> <Plug>NetrwCLeftmouse <leftmouse>:call <SID>NetrwCLeftmouse(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6373 | nno <buffer> <silent> <Plug>NetrwMiddlemouse <leftmouse>:call <SID>NetrwPrevWinOpen(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6374 | nno <buffer> <silent> <Plug>NetrwSLeftmouse <leftmouse>:call <SID>NetrwSLeftmouse(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6375 | nno <buffer> <silent> <Plug>NetrwSLeftdrag <leftmouse>:call <SID>NetrwSLeftdrag(1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6376 | nmap <buffer> <silent> <Plug>Netrw2Leftmouse - |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6377 | exe 'nnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
| 6378 | exe 'vnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6379 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6380 | exe 'nnoremap <buffer> <silent> <nowait> <del> :call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
| 6381 | exe 'nnoremap <buffer> <silent> <nowait> D :call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
| 6382 | exe 'nnoremap <buffer> <silent> <nowait> R :call <SID>NetrwLocalRename("'.mapsafecurdir.'")<cr>' |
| 6383 | exe 'nnoremap <buffer> <silent> <nowait> d :call <SID>NetrwMakeDir("")<cr>' |
| 6384 | exe 'vnoremap <buffer> <silent> <nowait> <del> :call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
| 6385 | exe 'vnoremap <buffer> <silent> <nowait> D :call <SID>NetrwLocalRm("'.mapsafecurdir.'")<cr>' |
| 6386 | exe 'vnoremap <buffer> <silent> <nowait> R :call <SID>NetrwLocalRename("'.mapsafecurdir.'")<cr>' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6387 | nnoremap <buffer> <F1> :he netrw-quickhelp<cr> |
| 6388 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6389 | " support user-specified maps |
| 6390 | call netrw#UserMaps(1) |
| 6391 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6392 | else |
| 6393 | " remote normal-mode maps {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6394 | " call Decho("make remote maps",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6395 | call s:RemotePathAnalysis(b:netrw_curdir) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6396 | nnoremap <buffer> <silent> <Plug>NetrwHide_a :<c-u>call <SID>NetrwHide(0)<cr> |
| 6397 | nnoremap <buffer> <silent> <Plug>NetrwBrowseUpDir :<c-u>call <SID>NetrwBrowseUpDir(0)<cr> |
| 6398 | nnoremap <buffer> <silent> <Plug>NetrwOpenFile :<c-u>call <SID>NetrwOpenFile(0)<cr> |
| 6399 | nnoremap <buffer> <silent> <Plug>NetrwBadd_cb :<c-u>call <SID>NetrwBadd(0,0)<cr> |
| 6400 | nnoremap <buffer> <silent> <Plug>NetrwBadd_cB :<c-u>call <SID>NetrwBadd(0,1)<cr> |
| 6401 | nnoremap <buffer> <silent> <Plug>NetrwLcd :<c-u>call <SID>NetrwLcd(b:netrw_curdir)<cr> |
| 6402 | nnoremap <buffer> <silent> <Plug>NetrwSetChgwin :<c-u>call <SID>NetrwSetChgwin()<cr> |
| 6403 | nnoremap <buffer> <silent> <Plug>NetrwRefresh :<c-u>call <SID>NetrwRefresh(0,<SID>NetrwBrowseChgDir(0,'./'))<cr> |
| 6404 | nnoremap <buffer> <silent> <Plug>NetrwLocalBrowseCheck :<c-u>call <SID>NetrwBrowse(0,<SID>NetrwBrowseChgDir(0,<SID>NetrwGetWord()))<cr> |
| 6405 | nnoremap <buffer> <silent> <Plug>NetrwServerEdit :<c-u>call <SID>NetrwServerEdit(2,<SID>NetrwGetWord())<cr> |
| 6406 | nnoremap <buffer> <silent> <Plug>NetrwBookHistHandler_gb :<c-u>call <SID>NetrwBookHistHandler(1,b:netrw_curdir)<cr> |
| 6407 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6408 | nnoremap <buffer> <silent> <nowait> gd :<c-u>call <SID>NetrwForceChgDir(0,<SID>NetrwGetWord())<cr> |
| 6409 | nnoremap <buffer> <silent> <nowait> gf :<c-u>call <SID>NetrwForceFile(0,<SID>NetrwGetWord())<cr> |
| 6410 | nnoremap <buffer> <silent> <nowait> gh :<c-u>call <SID>NetrwHidden(0)<cr> |
| 6411 | nnoremap <buffer> <silent> <nowait> gp :<c-u>call <SID>NetrwChgPerm(0,b:netrw_curdir)<cr> |
| 6412 | nnoremap <buffer> <silent> <nowait> I :<c-u>call <SID>NetrwBannerCtrl(1)<cr> |
| 6413 | nnoremap <buffer> <silent> <nowait> i :<c-u>call <SID>NetrwListStyle(0)<cr> |
| 6414 | nnoremap <buffer> <silent> <nowait> ma :<c-u>call <SID>NetrwMarkFileArgList(0,0)<cr> |
| 6415 | nnoremap <buffer> <silent> <nowait> mA :<c-u>call <SID>NetrwMarkFileArgList(0,1)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6416 | nnoremap <buffer> <silent> <nowait> mb :<c-u>call <SID>NetrwBookHistHandler(0,b:netrw_curdir)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6417 | nnoremap <buffer> <silent> <nowait> mB :<c-u>call <SID>NetrwBookHistHandler(6,b:netrw_curdir)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6418 | nnoremap <buffer> <silent> <nowait> mc :<c-u>call <SID>NetrwMarkFileCopy(0)<cr> |
| 6419 | nnoremap <buffer> <silent> <nowait> md :<c-u>call <SID>NetrwMarkFileDiff(0)<cr> |
| 6420 | nnoremap <buffer> <silent> <nowait> me :<c-u>call <SID>NetrwMarkFileEdit(0)<cr> |
| 6421 | nnoremap <buffer> <silent> <nowait> mf :<c-u>call <SID>NetrwMarkFile(0,<SID>NetrwGetWord())<cr> |
| 6422 | nnoremap <buffer> <silent> <nowait> mF :<c-u>call <SID>NetrwUnmarkList(bufnr("%"),b:netrw_curdir)<cr> |
| 6423 | nnoremap <buffer> <silent> <nowait> mg :<c-u>call <SID>NetrwMarkFileGrep(0)<cr> |
| 6424 | nnoremap <buffer> <silent> <nowait> mh :<c-u>call <SID>NetrwMarkHideSfx(0)<cr> |
| 6425 | nnoremap <buffer> <silent> <nowait> mm :<c-u>call <SID>NetrwMarkFileMove(0)<cr> |
| 6426 | nnoremap <buffer> <silent> <nowait> mp :<c-u>call <SID>NetrwMarkFilePrint(0)<cr> |
| 6427 | nnoremap <buffer> <silent> <nowait> mr :<c-u>call <SID>NetrwMarkFileRegexp(0)<cr> |
| 6428 | nnoremap <buffer> <silent> <nowait> ms :<c-u>call <SID>NetrwMarkFileSource(0)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6429 | nnoremap <buffer> <silent> <nowait> mT :<c-u>call <SID>NetrwMarkFileTag(0)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6430 | nnoremap <buffer> <silent> <nowait> mt :<c-u>call <SID>NetrwMarkFileTgt(0)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6431 | nnoremap <buffer> <silent> <nowait> mu :<c-u>call <SID>NetrwUnMarkFile(0)<cr> |
| 6432 | nnoremap <buffer> <silent> <nowait> mv :<c-u>call <SID>NetrwMarkFileVimCmd(0)<cr> |
| 6433 | nnoremap <buffer> <silent> <nowait> mx :<c-u>call <SID>NetrwMarkFileExe(0,0)<cr> |
| 6434 | nnoremap <buffer> <silent> <nowait> mX :<c-u>call <SID>NetrwMarkFileExe(0,1)<cr> |
| 6435 | nnoremap <buffer> <silent> <nowait> mz :<c-u>call <SID>NetrwMarkFileCompress(0)<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6436 | nnoremap <buffer> <silent> <nowait> O :<c-u>call <SID>NetrwObtain(0)<cr> |
| 6437 | nnoremap <buffer> <silent> <nowait> o :call <SID>NetrwSplit(0)<cr> |
| 6438 | nnoremap <buffer> <silent> <nowait> p :<c-u>call <SID>NetrwPreview(<SID>NetrwBrowseChgDir(1,<SID>NetrwGetWord(),1))<cr> |
| 6439 | nnoremap <buffer> <silent> <nowait> P :<c-u>call <SID>NetrwPrevWinOpen(0)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6440 | nnoremap <buffer> <silent> <nowait> qb :<c-u>call <SID>NetrwBookHistHandler(2,b:netrw_curdir)<cr> |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6441 | nnoremap <buffer> <silent> <nowait> qf :<c-u>call <SID>NetrwFileInfo(0,<SID>NetrwGetWord())<cr> |
| 6442 | nnoremap <buffer> <silent> <nowait> qF :<c-u>call <SID>NetrwMarkFileQFEL(0,getqflist())<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6443 | nnoremap <buffer> <silent> <nowait> qL :<c-u>call <SID>NetrwMarkFileQFEL(0,getloclist(v:count))<cr> |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 6444 | nnoremap <buffer> <silent> <nowait> r :<c-u>let g:netrw_sort_direction= (g:netrw_sort_direction =~# 'n')? 'r' : 'n'<bar>exe "norm! 0"<bar>call <SID>NetrwBrowse(0,<SID>NetrwBrowseChgDir(0,'./'))<cr> |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6445 | nnoremap <buffer> <silent> <nowait> s :call <SID>NetrwSortStyle(0)<cr> |
| 6446 | nnoremap <buffer> <silent> <nowait> S :<c-u>call <SID>NetSortSequence(0)<cr> |
| 6447 | nnoremap <buffer> <silent> <nowait> Tb :<c-u>call <SID>NetrwSetTgt(0,'b',v:count1)<cr> |
| 6448 | nnoremap <buffer> <silent> <nowait> t :call <SID>NetrwSplit(1)<cr> |
| 6449 | nnoremap <buffer> <silent> <nowait> Th :<c-u>call <SID>NetrwSetTgt(0,'h',v:count)<cr> |
| 6450 | nnoremap <buffer> <silent> <nowait> u :<c-u>call <SID>NetrwBookHistHandler(4,b:netrw_curdir)<cr> |
| 6451 | nnoremap <buffer> <silent> <nowait> U :<c-u>call <SID>NetrwBookHistHandler(5,b:netrw_curdir)<cr> |
| 6452 | nnoremap <buffer> <silent> <nowait> v :call <SID>NetrwSplit(2)<cr> |
| 6453 | nnoremap <buffer> <silent> <nowait> x :<c-u>call netrw#BrowseX(<SID>NetrwBrowseChgDir(0,<SID>NetrwGetWord()),1)<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6454 | if !hasmapto('<Plug>NetrwHideEdit') |
| 6455 | nmap <buffer> <c-h> <Plug>NetrwHideEdit |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6456 | endif |
| 6457 | nnoremap <buffer> <silent> <Plug>NetrwHideEdit :call <SID>NetrwHideEdit(0)<cr> |
| 6458 | if !hasmapto('<Plug>NetrwRefresh') |
| 6459 | nmap <buffer> <c-l> <Plug>NetrwRefresh |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6460 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6461 | if !hasmapto('<Plug>NetrwTreeSqueeze') |
| 6462 | nmap <buffer> <silent> <nowait> <s-cr> <Plug>NetrwTreeSqueeze |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6463 | endif |
| 6464 | nnoremap <buffer> <silent> <Plug>NetrwTreeSqueeze :call <SID>TreeSqueezeDir(0)<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6465 | |
| 6466 | let mapsafepath = escape(s:path, s:netrw_map_escape) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6467 | let mapsafeusermach = escape(((s:user == "")? "" : s:user."@").s:machine, s:netrw_map_escape) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6468 | |
| 6469 | nnoremap <buffer> <silent> <Plug>NetrwRefresh :call <SID>NetrwRefresh(0,<SID>NetrwBrowseChgDir(0,'./'))<cr> |
| 6470 | if g:netrw_mousemaps == 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6471 | nmap <buffer> <leftmouse> <Plug>NetrwLeftmouse |
| 6472 | nno <buffer> <silent> <Plug>NetrwLeftmouse <leftmouse>:call <SID>NetrwLeftmouse(0)<cr> |
| 6473 | nmap <buffer> <c-leftmouse> <Plug>NetrwCLeftmouse |
| 6474 | nno <buffer> <silent> <Plug>NetrwCLeftmouse <leftmouse>:call <SID>NetrwCLeftmouse(0)<cr> |
| 6475 | nmap <buffer> <s-leftmouse> <Plug>NetrwSLeftmouse |
| 6476 | nno <buffer> <silent> <Plug>NetrwSLeftmouse <leftmouse>:call <SID>NetrwSLeftmouse(0)<cr> |
| 6477 | nmap <buffer> <s-leftdrag> <Plug>NetrwSLeftdrag |
| 6478 | nno <buffer> <silent> <Plug>NetrwSLeftdrag <leftmouse>:call <SID>NetrwSLeftdrag(0)<cr> |
| 6479 | nmap <middlemouse> <Plug>NetrwMiddlemouse |
| 6480 | nno <buffer> <silent> <middlemouse> <Plug>NetrwMiddlemouse <leftmouse>:call <SID>NetrwPrevWinOpen(0)<cr> |
| 6481 | nmap <buffer> <2-leftmouse> <Plug>Netrw2Leftmouse |
| 6482 | nmap <buffer> <silent> <Plug>Netrw2Leftmouse - |
| 6483 | imap <buffer> <leftmouse> <Plug>ILeftmouse |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6484 | imap <buffer> <middlemouse> <Plug>IMiddlemouse |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6485 | imap <buffer> <s-leftmouse> <Plug>ISLeftmouse |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6486 | exe 'nnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6487 | exe 'vnoremap <buffer> <silent> <rightmouse> <leftmouse>:call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6488 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6489 | exe 'nnoremap <buffer> <silent> <nowait> <del> :call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6490 | exe 'nnoremap <buffer> <silent> <nowait> d :call <SID>NetrwMakeDir("'.mapsafeusermach.'")<cr>' |
| 6491 | exe 'nnoremap <buffer> <silent> <nowait> D :call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6492 | exe 'nnoremap <buffer> <silent> <nowait> R :call <SID>NetrwRemoteRename("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6493 | exe 'vnoremap <buffer> <silent> <nowait> <del> :call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6494 | exe 'vnoremap <buffer> <silent> <nowait> D :call <SID>NetrwRemoteRm("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
| 6495 | exe 'vnoremap <buffer> <silent> <nowait> R :call <SID>NetrwRemoteRename("'.mapsafeusermach.'","'.mapsafepath.'")<cr>' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6496 | nnoremap <buffer> <F1> :he netrw-quickhelp<cr> |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6497 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6498 | " support user-specified maps |
| 6499 | call netrw#UserMaps(0) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6500 | endif " }}}3 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6501 | |
| 6502 | " call Dret("s:NetrwMaps") |
| 6503 | endfun |
| 6504 | |
| 6505 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6506 | " s:NetrwCommands: set up commands {{{2 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6507 | " If -buffer, the command is only available from within netrw buffers |
| 6508 | " Otherwise, the command is available from any window, so long as netrw |
| 6509 | " has been used at least once in the session. |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6510 | fun! s:NetrwCommands(islocal) |
| 6511 | " call Dfunc("s:NetrwCommands(islocal=".a:islocal.")") |
| 6512 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6513 | com! -nargs=* -complete=file -bang NetrwMB call s:NetrwBookmark(<bang>0,<f-args>) |
| 6514 | com! -nargs=* NetrwC call s:NetrwSetChgwin(<q-args>) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6515 | com! Rexplore if exists("w:netrw_rexlocal")|call s:NetrwRexplore(w:netrw_rexlocal,exists("w:netrw_rexdir")? w:netrw_rexdir : ".")|else|call netrw#ErrorMsg(s:WARNING,"win#".winnr()." not a former netrw window",79)|endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6516 | if a:islocal |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6517 | com! -buffer -nargs=+ -complete=file MF call s:NetrwMarkFiles(1,<f-args>) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6518 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6519 | com! -buffer -nargs=+ -complete=file MF call s:NetrwMarkFiles(0,<f-args>) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6520 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6521 | com! -buffer -nargs=? -complete=file MT call s:NetrwMarkTarget(<q-args>) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6522 | |
| 6523 | " call Dret("s:NetrwCommands") |
| 6524 | endfun |
| 6525 | |
| 6526 | " --------------------------------------------------------------------- |
| 6527 | " s:NetrwMarkFiles: apply s:NetrwMarkFile() to named file(s) {{{2 |
| 6528 | " glob()ing only works with local files |
| 6529 | fun! s:NetrwMarkFiles(islocal,...) |
| 6530 | " call Dfunc("s:NetrwMarkFiles(islocal=".a:islocal."...) a:0=".a:0) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6531 | let curdir = s:NetrwGetCurdir(a:islocal) |
| 6532 | let i = 1 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6533 | while i <= a:0 |
| 6534 | if a:islocal |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 6535 | if v:version > 704 || (v:version == 704 && has("patch656")) |
| 6536 | let mffiles= glob(fnameescape(a:{i}),0,1,1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6537 | else |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 6538 | let mffiles= glob(fnameescape(a:{i}),0,1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6539 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6540 | else |
| 6541 | let mffiles= [a:{i}] |
| 6542 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6543 | " call Decho("mffiles".string(mffiles),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6544 | for mffile in mffiles |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6545 | " call Decho("mffile<".mffile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6546 | call s:NetrwMarkFile(a:islocal,mffile) |
| 6547 | endfor |
| 6548 | let i= i + 1 |
| 6549 | endwhile |
| 6550 | " call Dret("s:NetrwMarkFiles") |
| 6551 | endfun |
| 6552 | |
| 6553 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6554 | " s:NetrwMarkTarget: implements :MT (mark target) {{{2 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6555 | fun! s:NetrwMarkTarget(...) |
| 6556 | " call Dfunc("s:NetrwMarkTarget() a:0=".a:0) |
| 6557 | if a:0 == 0 || (a:0 == 1 && a:1 == "") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6558 | let curdir = s:NetrwGetCurdir(1) |
| 6559 | let tgt = b:netrw_curdir |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6560 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6561 | let curdir = s:NetrwGetCurdir((a:1 =~ '^\a\{3,}://')? 0 : 1) |
| 6562 | let tgt = a:1 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6563 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6564 | " call Decho("tgt<".tgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6565 | let s:netrwmftgt = tgt |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6566 | let s:netrwmftgt_islocal = tgt !~ '^\a\{3,}://' |
| 6567 | let curislocal = b:netrw_curdir !~ '^\a\{3,}://' |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6568 | let svpos = winsaveview() |
| 6569 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6570 | call s:NetrwRefresh(curislocal,s:NetrwBrowseChgDir(curislocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6571 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6572 | call winrestview(svpos) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6573 | " call Dret("s:NetrwMarkTarget") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6574 | endfun |
| 6575 | |
| 6576 | " --------------------------------------------------------------------- |
| 6577 | " s:NetrwMarkFile: (invoked by mf) This function is used to both {{{2 |
| 6578 | " mark and unmark files. If a markfile list exists, |
| 6579 | " then the rename and delete functions will use it instead |
| 6580 | " of whatever may happen to be under the cursor at that |
| 6581 | " moment. When the mouse and gui are available, |
| 6582 | " shift-leftmouse may also be used to mark files. |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 6583 | " |
| 6584 | " Creates two lists |
| 6585 | " s:netrwmarkfilelist -- holds complete paths to all marked files |
| 6586 | " s:netrwmarkfilelist_# -- holds list of marked files in current-buffer's directory (#==bufnr()) |
| 6587 | " |
| 6588 | " Creates a marked file match string |
| 6589 | " s:netrwmarfilemtch_# -- used with 2match to display marked files |
| 6590 | " |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 6591 | " Creates a buffer version of islocal |
| 6592 | " b:netrw_islocal |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6593 | fun! s:NetrwMarkFile(islocal,fname) |
| 6594 | " call Dfunc("s:NetrwMarkFile(islocal=".a:islocal." fname<".a:fname.">)") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6595 | " call Decho("bufnr(%)=".bufnr("%").": ".bufname("%"),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6596 | |
| 6597 | " sanity check |
| 6598 | if empty(a:fname) |
| 6599 | " call Dret("s:NetrwMarkFile : emtpy fname") |
| 6600 | return |
| 6601 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6602 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6603 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6604 | let ykeep = @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6605 | let curbufnr= bufnr("%") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6606 | if a:fname =~ '^\a' |
| 6607 | let leader= '\<' |
| 6608 | else |
| 6609 | let leader= '' |
| 6610 | endif |
| 6611 | if a:fname =~ '\a$' |
| 6612 | let trailer = '\>[@=|\/\*]\=\ze\%( \|\t\|$\)' |
| 6613 | else |
| 6614 | let trailer = '[@=|\/\*]\=\ze\%( \|\t\|$\)' |
| 6615 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 6616 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6617 | if exists("s:netrwmarkfilelist_".curbufnr) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 6618 | " markfile list pre-exists |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6619 | " call Decho("case s:netrwmarkfilelist_".curbufnr." already exists",'~'.expand("<slnum>")) |
| 6620 | " call Decho("starting s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}).">",'~'.expand("<slnum>")) |
| 6621 | " call Decho("starting s:netrwmarkfilemtch_".curbufnr."<".s:netrwmarkfilemtch_{curbufnr}.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 6622 | let b:netrw_islocal= a:islocal |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6623 | |
| 6624 | if index(s:netrwmarkfilelist_{curbufnr},a:fname) == -1 |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 6625 | " append filename to buffer's markfilelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6626 | " call Decho("append filename<".a:fname."> to local markfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6627 | call add(s:netrwmarkfilelist_{curbufnr},a:fname) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6628 | let s:netrwmarkfilemtch_{curbufnr}= s:netrwmarkfilemtch_{curbufnr}.'\|'.leader.escape(a:fname,g:netrw_markfileesc).trailer |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6629 | |
| 6630 | else |
Bram Moolenaar | ed39e1d | 2008-08-09 17:55:22 +0000 | [diff] [blame] | 6631 | " remove filename from buffer's markfilelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6632 | " call Decho("remove filename<".a:fname."> from local markfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6633 | call filter(s:netrwmarkfilelist_{curbufnr},'v:val != a:fname') |
| 6634 | if s:netrwmarkfilelist_{curbufnr} == [] |
| 6635 | " local markfilelist is empty; remove it entirely |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6636 | " call Decho("markfile list now empty",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6637 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 6638 | else |
| 6639 | " rebuild match list to display markings correctly |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6640 | " call Decho("rebuild s:netrwmarkfilemtch_".curbufnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6641 | let s:netrwmarkfilemtch_{curbufnr}= "" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6642 | let first = 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6643 | for fname in s:netrwmarkfilelist_{curbufnr} |
| 6644 | if first |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6645 | let s:netrwmarkfilemtch_{curbufnr}= s:netrwmarkfilemtch_{curbufnr}.leader.escape(fname,g:netrw_markfileesc).trailer |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6646 | else |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6647 | let s:netrwmarkfilemtch_{curbufnr}= s:netrwmarkfilemtch_{curbufnr}.'\|'.leader.escape(fname,g:netrw_markfileesc).trailer |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6648 | endif |
| 6649 | let first= 0 |
| 6650 | endfor |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6651 | " call Decho("ending s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6652 | endif |
| 6653 | endif |
| 6654 | |
| 6655 | else |
| 6656 | " initialize new markfilelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6657 | " call Decho("case: initialize new markfilelist",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6658 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6659 | " call Decho("add fname<".a:fname."> to new markfilelist_".curbufnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6660 | let s:netrwmarkfilelist_{curbufnr}= [] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6661 | call add(s:netrwmarkfilelist_{curbufnr},substitute(a:fname,'[|@]$','','')) |
| 6662 | " call Decho("ending s:netrwmarkfilelist_{curbufnr}<".string(s:netrwmarkfilelist_{curbufnr}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6663 | |
| 6664 | " build initial markfile matching pattern |
| 6665 | if a:fname =~ '/$' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6666 | let s:netrwmarkfilemtch_{curbufnr}= leader.escape(a:fname,g:netrw_markfileesc) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6667 | else |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 6668 | let s:netrwmarkfilemtch_{curbufnr}= leader.escape(a:fname,g:netrw_markfileesc).trailer |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6669 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6670 | " call Decho("ending s:netrwmarkfilemtch_".curbufnr."<".s:netrwmarkfilemtch_{curbufnr}.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6671 | endif |
| 6672 | |
| 6673 | " handle global markfilelist |
| 6674 | if exists("s:netrwmarkfilelist") |
| 6675 | let dname= s:ComposePath(b:netrw_curdir,a:fname) |
| 6676 | if index(s:netrwmarkfilelist,dname) == -1 |
| 6677 | " append new filename to global markfilelist |
| 6678 | call add(s:netrwmarkfilelist,s:ComposePath(b:netrw_curdir,a:fname)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6679 | " call Decho("append filename<".a:fname."> to global markfilelist<".string(s:netrwmarkfilelist).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6680 | else |
| 6681 | " remove new filename from global markfilelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6682 | " call Decho("filter(".string(s:netrwmarkfilelist).",'v:val != '.".dname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6683 | call filter(s:netrwmarkfilelist,'v:val != "'.dname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6684 | " call Decho("ending s:netrwmarkfilelist <".string(s:netrwmarkfilelist).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6685 | if s:netrwmarkfilelist == [] |
| 6686 | unlet s:netrwmarkfilelist |
| 6687 | endif |
| 6688 | endif |
| 6689 | else |
| 6690 | " initialize new global-directory markfilelist |
| 6691 | let s:netrwmarkfilelist= [] |
| 6692 | call add(s:netrwmarkfilelist,s:ComposePath(b:netrw_curdir,a:fname)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6693 | " call Decho("init s:netrwmarkfilelist<".string(s:netrwmarkfilelist).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6694 | endif |
| 6695 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6696 | " set up 2match'ing to netrwmarkfilemtch_# list |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6697 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 6698 | if exists("s:netrwmarkfilemtch_{curbufnr}") && s:netrwmarkfilemtch_{curbufnr} != "" |
| 6699 | " " call Decho("exe 2match netrwMarkFile /".s:netrwmarkfilemtch_{curbufnr}."/",'~'.expand("<slnum>")) |
| 6700 | if exists("g:did_drchip_netrwlist_syntax") |
| 6701 | exe "2match netrwMarkFile /".s:netrwmarkfilemtch_{curbufnr}."/" |
| 6702 | endif |
| 6703 | else |
| 6704 | " " call Decho("2match none",'~'.expand("<slnum>")) |
| 6705 | 2match none |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 6706 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6707 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6708 | let @@= ykeep |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 6709 | " call Dret("s:NetrwMarkFile : s:netrwmarkfilelist_".curbufnr."<".(exists("s:netrwmarkfilelist_{curbufnr}")? string(s:netrwmarkfilelist_{curbufnr}) : " doesn't exist").">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6710 | endfun |
| 6711 | |
| 6712 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6713 | " s:NetrwMarkFileArgList: ma: move the marked file list to the argument list (tomflist=0) {{{2 |
| 6714 | " mA: move the argument list to marked file list (tomflist=1) |
| 6715 | " Uses the global marked file list |
| 6716 | fun! s:NetrwMarkFileArgList(islocal,tomflist) |
| 6717 | " call Dfunc("s:NetrwMarkFileArgList(islocal=".a:islocal.",tomflist=".a:tomflist.")") |
| 6718 | |
| 6719 | let svpos = winsaveview() |
| 6720 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6721 | let curdir = s:NetrwGetCurdir(a:islocal) |
| 6722 | let curbufnr = bufnr("%") |
| 6723 | |
| 6724 | if a:tomflist |
| 6725 | " mA: move argument list to marked file list |
| 6726 | while argc() |
| 6727 | let fname= argv(0) |
| 6728 | " call Decho("exe argdel ".fname,'~'.expand("<slnum>")) |
| 6729 | exe "argdel ".fnameescape(fname) |
| 6730 | call s:NetrwMarkFile(a:islocal,fname) |
| 6731 | endwhile |
| 6732 | |
| 6733 | else |
| 6734 | " ma: move marked file list to argument list |
| 6735 | if exists("s:netrwmarkfilelist") |
| 6736 | |
| 6737 | " for every filename in the marked list |
| 6738 | for fname in s:netrwmarkfilelist |
| 6739 | " call Decho("exe argadd ".fname,'~'.expand("<slnum>")) |
| 6740 | exe "argadd ".fnameescape(fname) |
| 6741 | endfor " for every file in the marked list |
| 6742 | |
| 6743 | " unmark list and refresh |
| 6744 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 6745 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 6746 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6747 | NetrwKeepj call winrestview(svpos) |
| 6748 | endif |
| 6749 | endif |
| 6750 | |
| 6751 | " call Dret("s:NetrwMarkFileArgList") |
| 6752 | endfun |
| 6753 | |
| 6754 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6755 | " s:NetrwMarkFileCompress: (invoked by mz) This function is used to {{{2 |
| 6756 | " compress/decompress files using the programs |
| 6757 | " in g:netrw_compress and g:netrw_uncompress, |
| 6758 | " using g:netrw_compress_suffix to know which to |
| 6759 | " do. By default: |
| 6760 | " g:netrw_compress = "gzip" |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 6761 | " g:netrw_decompress = { ".gz" : "gunzip" , ".bz2" : "bunzip2" , ".zip" : "unzip" , ".tar" : "tar -xf", ".xz" : "unxz"} |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6762 | fun! s:NetrwMarkFileCompress(islocal) |
| 6763 | " call Dfunc("s:NetrwMarkFileCompress(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6764 | let svpos = winsaveview() |
| 6765 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6766 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6767 | let curbufnr = bufnr("%") |
| 6768 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6769 | " sanity check |
| 6770 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6771 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6772 | " call Dret("s:NetrwMarkFileCompress") |
| 6773 | return |
| 6774 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6775 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6776 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6777 | if exists("s:netrwmarkfilelist_{curbufnr}") && exists("g:netrw_compress") && exists("g:netrw_decompress") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6778 | |
| 6779 | " for every filename in the marked list |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6780 | for fname in s:netrwmarkfilelist_{curbufnr} |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6781 | let sfx= substitute(fname,'^.\{-}\(\.\a\+\)$','\1','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6782 | " call Decho("extracted sfx<".sfx.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6783 | if exists("g:netrw_decompress['".sfx."']") |
| 6784 | " fname has a suffix indicating that its compressed; apply associated decompression routine |
| 6785 | let exe= g:netrw_decompress[sfx] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6786 | " call Decho("fname<".fname."> is compressed so decompress with <".exe.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6787 | let exe= netrw#WinPath(exe) |
| 6788 | if a:islocal |
| 6789 | if g:netrw_keepdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6790 | let fname= s:ShellEscape(s:ComposePath(curdir,fname)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6791 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6792 | call system(exe." ".fname) |
| 6793 | if v:shell_error |
| 6794 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"unable to apply<".exe."> to file<".fname.">",50) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6795 | endif |
| 6796 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6797 | let fname= s:ShellEscape(b:netrw_curdir.fname,1) |
| 6798 | NetrwKeepj call s:RemoteSystem(exe." ".fname) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6799 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6800 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6801 | endif |
| 6802 | unlet sfx |
| 6803 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6804 | if exists("exe") |
| 6805 | unlet exe |
| 6806 | elseif a:islocal |
| 6807 | " fname not a compressed file, so compress it |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6808 | call system(netrw#WinPath(g:netrw_compress)." ".s:ShellEscape(s:ComposePath(b:netrw_curdir,fname))) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6809 | if v:shell_error |
| 6810 | call netrw#ErrorMsg(s:WARNING,"consider setting g:netrw_compress<".g:netrw_compress."> to something that works",104) |
| 6811 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6812 | else |
| 6813 | " fname not a compressed file, so compress it |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6814 | NetrwKeepj call s:RemoteSystem(netrw#WinPath(g:netrw_compress)." ".s:ShellEscape(fname)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6815 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6816 | endfor " for every file in the marked list |
| 6817 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6818 | call s:NetrwUnmarkList(curbufnr,curdir) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6819 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6820 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 6821 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6822 | endif |
| 6823 | " call Dret("s:NetrwMarkFileCompress") |
| 6824 | endfun |
| 6825 | |
| 6826 | " --------------------------------------------------------------------- |
| 6827 | " s:NetrwMarkFileCopy: (invoked by mc) copy marked files to target {{{2 |
| 6828 | " If no marked files, then set up directory as the |
| 6829 | " target. Currently does not support copying entire |
| 6830 | " directories. Uses the local-buffer marked file list. |
| 6831 | " Returns 1=success (used by NetrwMarkFileMove()) |
| 6832 | " 0=failure |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6833 | fun! s:NetrwMarkFileCopy(islocal,...) |
| 6834 | " call Dfunc("s:NetrwMarkFileCopy(islocal=".a:islocal.") target<".(exists("s:netrwmftgt")? s:netrwmftgt : '---')."> a:0=".a:0) |
| 6835 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6836 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6837 | let curbufnr = bufnr("%") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6838 | if b:netrw_curdir !~ '/$' |
| 6839 | if !exists("b:netrw_curdir") |
| 6840 | let b:netrw_curdir= curdir |
| 6841 | endif |
| 6842 | let b:netrw_curdir= b:netrw_curdir."/" |
| 6843 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6844 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6845 | " sanity check |
| 6846 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6847 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6848 | " call Dret("s:NetrwMarkFileCopy") |
| 6849 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6850 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6851 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6852 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6853 | if !exists("s:netrwmftgt") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6854 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"your marked file target is empty! (:help netrw-mt)",67) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6855 | " call Dret("s:NetrwMarkFileCopy 0") |
| 6856 | return 0 |
| 6857 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6858 | " call Decho("sanity chk passed: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6859 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6860 | if a:islocal && s:netrwmftgt_islocal |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6861 | " Copy marked files, local directory to local directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6862 | " call Decho("copy from local to local",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6863 | if !executable(g:netrw_localcopycmd) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6864 | call netrw#ErrorMsg(s:ERROR,"g:netrw_localcopycmd<".g:netrw_localcopycmd."> not executable on your system, aborting",91) |
| 6865 | " call Dfunc("s:NetrwMarkFileMove : g:netrw_localcopycmd<".g:netrw_localcopycmd."> n/a!") |
| 6866 | return |
| 6867 | endif |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6868 | |
| 6869 | " copy marked files while within the same directory (ie. allow renaming) |
| 6870 | if simplify(s:netrwmftgt) == simplify(b:netrw_curdir) |
| 6871 | if len(s:netrwmarkfilelist_{bufnr('%')}) == 1 |
| 6872 | " only one marked file |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6873 | " call Decho("case: only one marked file",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6874 | let args = s:ShellEscape(b:netrw_curdir.s:netrwmarkfilelist_{bufnr('%')}[0]) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6875 | let oldname = s:netrwmarkfilelist_{bufnr('%')}[0] |
| 6876 | elseif a:0 == 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6877 | " call Decho("case: handling one input argument",'~'.expand("<slnum>")) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6878 | " this happens when the next case was used to recursively call s:NetrwMarkFileCopy() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6879 | let args = s:ShellEscape(b:netrw_curdir.a:1) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6880 | let oldname = a:1 |
| 6881 | else |
| 6882 | " copy multiple marked files inside the same directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6883 | " call Decho("case: handling a multiple marked files",'~'.expand("<slnum>")) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6884 | let s:recursive= 1 |
| 6885 | for oldname in s:netrwmarkfilelist_{bufnr("%")} |
| 6886 | let ret= s:NetrwMarkFileCopy(a:islocal,oldname) |
| 6887 | if ret == 0 |
| 6888 | break |
| 6889 | endif |
| 6890 | endfor |
| 6891 | unlet s:recursive |
| 6892 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 6893 | " call Dret("s:NetrwMarkFileCopy ".ret) |
| 6894 | return ret |
| 6895 | endif |
| 6896 | |
| 6897 | call inputsave() |
| 6898 | let newname= input("Copy ".oldname." to : ",oldname,"file") |
| 6899 | call inputrestore() |
| 6900 | if newname == "" |
| 6901 | " call Dret("s:NetrwMarkFileCopy 0") |
| 6902 | return 0 |
| 6903 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6904 | let args= s:ShellEscape(oldname) |
| 6905 | let tgt = s:ShellEscape(s:netrwmftgt.'/'.newname) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6906 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6907 | let args= join(map(deepcopy(s:netrwmarkfilelist_{bufnr('%')}),"s:ShellEscape(b:netrw_curdir.\"/\".v:val)")) |
| 6908 | let tgt = s:ShellEscape(s:netrwmftgt) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6909 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6910 | if !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 6911 | let args= substitute(args,'/','\\','g') |
| 6912 | let tgt = substitute(tgt, '/','\\','g') |
| 6913 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 6914 | if args =~ "'" |let args= substitute(args,"'\\(.*\\)'",'\1','')|endif |
| 6915 | if tgt =~ "'" |let tgt = substitute(tgt ,"'\\(.*\\)'",'\1','')|endif |
| 6916 | if args =~ '//'|let args= substitute(args,'//','/','g')|endif |
| 6917 | if tgt =~ '//'|let tgt = substitute(tgt ,'//','/','g')|endif |
| 6918 | " call Decho("args <".args.">",'~'.expand("<slnum>")) |
| 6919 | " call Decho("tgt <".tgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6920 | if isdirectory(s:NetrwFile(args)) |
| 6921 | " call Decho("args<".args."> is a directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6922 | let copycmd= g:netrw_localcopydircmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6923 | " call Decho("using copydircmd<".copycmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6924 | if !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 6925 | " window's xcopy doesn't copy a directory to a target properly. Instead, it copies a directory's |
| 6926 | " contents to a target. One must append the source directory name to the target to get xcopy to |
| 6927 | " do the right thing. |
| 6928 | let tgt= tgt.'\'.substitute(a:1,'^.*[\\/]','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6929 | " call Decho("modified tgt for xcopy",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6930 | endif |
| 6931 | else |
| 6932 | let copycmd= g:netrw_localcopycmd |
| 6933 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6934 | if g:netrw_localcopycmd =~ '\s' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6935 | let copycmd = substitute(copycmd,'\s.*$','','') |
| 6936 | let copycmdargs = substitute(copycmd,'^.\{-}\(\s.*\)$','\1','') |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6937 | let copycmd = netrw#WinPath(copycmd).copycmdargs |
| 6938 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6939 | let copycmd = netrw#WinPath(copycmd) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 6940 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6941 | " call Decho("args <".args.">",'~'.expand("<slnum>")) |
| 6942 | " call Decho("tgt <".tgt.">",'~'.expand("<slnum>")) |
| 6943 | " call Decho("copycmd<".copycmd.">",'~'.expand("<slnum>")) |
| 6944 | " call Decho("system(".copycmd." '".args."' '".tgt."')",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6945 | call system(copycmd.g:netrw_localcopycmdopt." '".args."' '".tgt."'") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6946 | if v:shell_error != 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6947 | if exists("b:netrw_curdir") && b:netrw_curdir != getcwd() && !g:netrw_keepdir |
| 6948 | call netrw#ErrorMsg(s:ERROR,"copy failed; perhaps due to vim's current directory<".getcwd()."> not matching netrw's (".b:netrw_curdir.") (see :help netrw-c)",101) |
| 6949 | else |
| 6950 | call netrw#ErrorMsg(s:ERROR,"tried using g:netrw_localcopycmd<".g:netrw_localcopycmd.">; it doesn't work!",80) |
| 6951 | endif |
| 6952 | " call Dret("s:NetrwMarkFileCopy 0 : failed: system(".g:netrw_localcopycmd." ".args." ".s:ShellEscape(s:netrwmftgt)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6953 | return 0 |
| 6954 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6955 | |
| 6956 | elseif a:islocal && !s:netrwmftgt_islocal |
| 6957 | " Copy marked files, local directory to remote directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6958 | " call Decho("copy from local to remote",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6959 | NetrwKeepj call s:NetrwUpload(s:netrwmarkfilelist_{bufnr('%')},s:netrwmftgt) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6960 | |
| 6961 | elseif !a:islocal && s:netrwmftgt_islocal |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6962 | " Copy marked files, remote directory to local directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6963 | " call Decho("copy from remote to local",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6964 | NetrwKeepj call netrw#Obtain(a:islocal,s:netrwmarkfilelist_{bufnr('%')},s:netrwmftgt) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6965 | |
| 6966 | elseif !a:islocal && !s:netrwmftgt_islocal |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 6967 | " Copy marked files, remote directory to remote directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6968 | " call Decho("copy from remote to remote",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6969 | let curdir = getcwd() |
| 6970 | let tmpdir = s:GetTempfile("") |
| 6971 | if tmpdir !~ '/' |
| 6972 | let tmpdir= curdir."/".tmpdir |
| 6973 | endif |
| 6974 | if exists("*mkdir") |
| 6975 | call mkdir(tmpdir) |
| 6976 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6977 | call s:NetrwExe("sil! !".g:netrw_localmkdir.g:netrw_localmkdiropt.' '.s:ShellEscape(tmpdir,1)) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6978 | if v:shell_error != 0 |
| 6979 | call netrw#ErrorMsg(s:WARNING,"consider setting g:netrw_localmkdir<".g:netrw_localmkdir."> to something that works",80) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6980 | " call Dret("s:NetrwMarkFileCopy : failed: sil! !".g:netrw_localmkdir.' '.s:ShellEscape(tmpdir,1) ) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 6981 | return |
| 6982 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6983 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 6984 | if isdirectory(s:NetrwFile(tmpdir)) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6985 | if s:NetrwLcd(tmpdir) |
| 6986 | " call Dret("s:NetrwMarkFileCopy : lcd failure") |
| 6987 | return |
| 6988 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6989 | NetrwKeepj call netrw#Obtain(a:islocal,s:netrwmarkfilelist_{bufnr('%')},tmpdir) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 6990 | let localfiles= map(deepcopy(s:netrwmarkfilelist_{bufnr('%')}),'substitute(v:val,"^.*/","","")') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6991 | NetrwKeepj call s:NetrwUpload(localfiles,s:netrwmftgt) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6992 | if getcwd() == tmpdir |
| 6993 | for fname in s:netrwmarkfilelist_{bufnr('%')} |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 6994 | NetrwKeepj call s:NetrwDelete(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 6995 | endfor |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 6996 | if s:NetrwLcd(curdir) |
| 6997 | " call Dret("s:NetrwMarkFileCopy : lcd failure") |
| 6998 | return |
| 6999 | endif |
| 7000 | if v:version < 704 || (v:version == 704 && !has("patch1107")) |
| 7001 | call s:NetrwExe("sil !".g:netrw_localrmdir.g:netrw_localrmdiropt." ".s:ShellEscape(tmpdir,1)) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7002 | if v:shell_error != 0 |
| 7003 | call netrw#ErrorMsg(s:WARNING,"consider setting g:netrw_localrmdir<".g:netrw_localrmdir."> to something that works",80) |
| 7004 | " " call Dret("s:NetrwMarkFileCopy : failed: sil !".g:netrw_localrmdir." ".s:ShellEscape(tmpdir,1) ) |
| 7005 | return |
| 7006 | endif |
| 7007 | else |
| 7008 | if delete(tmpdir,"d") |
| 7009 | call netrw#ErrorMsg(s:ERROR,"unable to delete directory <".tmpdir.">!",103) |
| 7010 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7011 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7012 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7013 | if s:NetrwLcd(curdir) |
| 7014 | " call Dret("s:NetrwMarkFileCopy : lcd failure") |
| 7015 | return |
| 7016 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7017 | endif |
| 7018 | endif |
| 7019 | endif |
| 7020 | |
| 7021 | " ------- |
| 7022 | " cleanup |
| 7023 | " ------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7024 | " call Decho("cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7025 | " remove markings from local buffer |
| 7026 | call s:NetrwUnmarkList(curbufnr,curdir) " remove markings from local buffer |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7027 | " call Decho(" g:netrw_fastbrowse =".g:netrw_fastbrowse,'~'.expand("<slnum>")) |
| 7028 | " call Decho(" s:netrwmftgt =".s:netrwmftgt,'~'.expand("<slnum>")) |
| 7029 | " call Decho(" s:netrwmftgt_islocal=".s:netrwmftgt_islocal,'~'.expand("<slnum>")) |
| 7030 | " call Decho(" curdir =".curdir,'~'.expand("<slnum>")) |
| 7031 | " call Decho(" a:islocal =".a:islocal,'~'.expand("<slnum>")) |
| 7032 | " call Decho(" curbufnr =".curbufnr,'~'.expand("<slnum>")) |
| 7033 | if exists("s:recursive") |
| 7034 | " call Decho(" s:recursive =".s:recursive,'~'.expand("<slnum>")) |
| 7035 | else |
| 7036 | " call Decho(" s:recursive =n/a",'~'.expand("<slnum>")) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 7037 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7038 | " see s:LocalFastBrowser() for g:netrw_fastbrowse interpretation (refreshing done for both slow and medium) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7039 | if g:netrw_fastbrowse <= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7040 | NetrwKeepj call s:LocalBrowseRefresh() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7041 | else |
| 7042 | " refresh local and targets for fast browsing |
| 7043 | if !exists("s:recursive") |
| 7044 | " remove markings from local buffer |
| 7045 | " call Decho(" remove markings from local buffer",'~'.expand("<slnum>")) |
| 7046 | NetrwKeepj call s:NetrwUnmarkList(curbufnr,curdir) |
| 7047 | endif |
| 7048 | |
| 7049 | " refresh buffers |
| 7050 | if s:netrwmftgt_islocal |
| 7051 | " call Decho(" refresh s:netrwmftgt=".s:netrwmftgt,'~'.expand("<slnum>")) |
| 7052 | NetrwKeepj call s:NetrwRefreshDir(s:netrwmftgt_islocal,s:netrwmftgt) |
| 7053 | endif |
| 7054 | if a:islocal && s:netrwmftgt != curdir |
| 7055 | " call Decho(" refresh curdir=".curdir,'~'.expand("<slnum>")) |
| 7056 | NetrwKeepj call s:NetrwRefreshDir(a:islocal,curdir) |
| 7057 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7058 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7059 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7060 | " call Dret("s:NetrwMarkFileCopy 1") |
| 7061 | return 1 |
| 7062 | endfun |
| 7063 | |
| 7064 | " --------------------------------------------------------------------- |
| 7065 | " s:NetrwMarkFileDiff: (invoked by md) This function is used to {{{2 |
| 7066 | " invoke vim's diff mode on the marked files. |
| 7067 | " Either two or three files can be so handled. |
| 7068 | " Uses the global marked file list. |
| 7069 | fun! s:NetrwMarkFileDiff(islocal) |
| 7070 | " call Dfunc("s:NetrwMarkFileDiff(islocal=".a:islocal.") b:netrw_curdir<".b:netrw_curdir.">") |
| 7071 | let curbufnr= bufnr("%") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7072 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7073 | " sanity check |
| 7074 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7075 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7076 | " call Dret("s:NetrwMarkFileDiff") |
| 7077 | return |
| 7078 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7079 | let curdir= s:NetrwGetCurdir(a:islocal) |
| 7080 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7081 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7082 | if exists("s:netrwmarkfilelist_{".curbufnr."}") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7083 | let cnt = 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7084 | for fname in s:netrwmarkfilelist |
| 7085 | let cnt= cnt + 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7086 | if cnt == 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7087 | " call Decho("diffthis: fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7088 | exe "NetrwKeepj e ".fnameescape(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7089 | diffthis |
| 7090 | elseif cnt == 2 || cnt == 3 |
| 7091 | vsplit |
| 7092 | wincmd l |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7093 | " call Decho("diffthis: ".fname,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7094 | exe "NetrwKeepj e ".fnameescape(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7095 | diffthis |
| 7096 | else |
| 7097 | break |
| 7098 | endif |
| 7099 | endfor |
| 7100 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 7101 | endif |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 7102 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7103 | " call Dret("s:NetrwMarkFileDiff") |
| 7104 | endfun |
| 7105 | |
| 7106 | " --------------------------------------------------------------------- |
| 7107 | " s:NetrwMarkFileEdit: (invoked by me) put marked files on arg list and start editing them {{{2 |
| 7108 | " Uses global markfilelist |
| 7109 | fun! s:NetrwMarkFileEdit(islocal) |
| 7110 | " call Dfunc("s:NetrwMarkFileEdit(islocal=".a:islocal.")") |
| 7111 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7112 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7113 | let curbufnr = bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7114 | |
| 7115 | " sanity check |
| 7116 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7117 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7118 | " call Dret("s:NetrwMarkFileEdit") |
| 7119 | return |
| 7120 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7121 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7122 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7123 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7124 | call s:SetRexDir(a:islocal,curdir) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 7125 | let flist= join(map(deepcopy(s:netrwmarkfilelist), "fnameescape(v:val)")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7126 | " unmark markedfile list |
| 7127 | " call s:NetrwUnmarkList(curbufnr,curdir) |
| 7128 | call s:NetrwUnmarkAll() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7129 | " call Decho("exe sil args ".flist,'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 7130 | exe "sil args ".flist |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7131 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7132 | echo "(use :bn, :bp to navigate files; :Rex to return)" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7133 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7134 | " call Dret("s:NetrwMarkFileEdit") |
| 7135 | endfun |
| 7136 | |
| 7137 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7138 | " s:NetrwMarkFileQFEL: convert a quickfix-error or location list into a marked file list {{{2 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7139 | fun! s:NetrwMarkFileQFEL(islocal,qfel) |
| 7140 | " call Dfunc("s:NetrwMarkFileQFEL(islocal=".a:islocal.",qfel)") |
| 7141 | call s:NetrwUnmarkAll() |
| 7142 | let curbufnr= bufnr("%") |
| 7143 | |
| 7144 | if !empty(a:qfel) |
| 7145 | for entry in a:qfel |
| 7146 | let bufnmbr= entry["bufnr"] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7147 | " call Decho("bufname(".bufnmbr.")<".bufname(bufnmbr)."> line#".entry["lnum"]." text=".entry["text"],'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7148 | if !exists("s:netrwmarkfilelist_{curbufnr}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7149 | " call Decho("case: no marked file list",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7150 | call s:NetrwMarkFile(a:islocal,bufname(bufnmbr)) |
| 7151 | elseif index(s:netrwmarkfilelist_{curbufnr},bufname(bufnmbr)) == -1 |
| 7152 | " s:NetrwMarkFile will remove duplicate entries from the marked file list. |
| 7153 | " So, this test lets two or more hits on the same pattern to be ignored. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7154 | " call Decho("case: ".bufname(bufnmbr)." not currently in marked file list",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7155 | call s:NetrwMarkFile(a:islocal,bufname(bufnmbr)) |
| 7156 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7157 | " call Decho("case: ".bufname(bufnmbr)." already in marked file list",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7158 | endif |
| 7159 | endfor |
| 7160 | echo "(use me to edit marked files)" |
| 7161 | else |
| 7162 | call netrw#ErrorMsg(s:WARNING,"can't convert quickfix error list; its empty!",92) |
| 7163 | endif |
| 7164 | |
| 7165 | " call Dret("s:NetrwMarkFileQFEL") |
| 7166 | endfun |
| 7167 | |
| 7168 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7169 | " s:NetrwMarkFileExe: (invoked by mx and mX) execute arbitrary system command on marked files {{{2 |
| 7170 | " mx enbloc=0: Uses the local marked-file list, applies command to each file individually |
| 7171 | " mX enbloc=1: Uses the global marked-file list, applies command to entire list |
| 7172 | fun! s:NetrwMarkFileExe(islocal,enbloc) |
| 7173 | " call Dfunc("s:NetrwMarkFileExe(islocal=".a:islocal.",enbloc=".a:enbloc.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7174 | let svpos = winsaveview() |
| 7175 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7176 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7177 | let curbufnr = bufnr("%") |
| 7178 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7179 | if a:enbloc == 0 |
| 7180 | " individually apply command to files, one at a time |
| 7181 | " sanity check |
| 7182 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
| 7183 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
| 7184 | " call Dret("s:NetrwMarkFileExe") |
| 7185 | return |
| 7186 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7187 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7188 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7189 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7190 | " get the command |
| 7191 | call inputsave() |
| 7192 | let cmd= input("Enter command: ","","file") |
| 7193 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7194 | " call Decho("cmd<".cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7195 | if cmd == "" |
| 7196 | " call Dret("s:NetrwMarkFileExe : early exit, empty command") |
| 7197 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7198 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7199 | |
| 7200 | " apply command to marked files, individually. Substitute: filename -> % |
| 7201 | " If no %, then append a space and the filename to the command |
| 7202 | for fname in s:netrwmarkfilelist_{curbufnr} |
| 7203 | if a:islocal |
| 7204 | if g:netrw_keepdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7205 | let fname= s:ShellEscape(netrw#WinPath(s:ComposePath(curdir,fname))) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7206 | endif |
| 7207 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7208 | let fname= s:ShellEscape(netrw#WinPath(b:netrw_curdir.fname)) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7209 | endif |
| 7210 | if cmd =~ '%' |
| 7211 | let xcmd= substitute(cmd,'%',fname,'g') |
| 7212 | else |
| 7213 | let xcmd= cmd.' '.fname |
| 7214 | endif |
| 7215 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7216 | " call Decho("local: xcmd<".xcmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7217 | let ret= system(xcmd) |
| 7218 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7219 | " call Decho("remote: xcmd<".xcmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7220 | let ret= s:RemoteSystem(xcmd) |
| 7221 | endif |
| 7222 | if v:shell_error < 0 |
| 7223 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"command<".xcmd."> failed, aborting",54) |
| 7224 | break |
| 7225 | else |
| 7226 | echo ret |
| 7227 | endif |
| 7228 | endfor |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7229 | |
| 7230 | " unmark marked file list |
| 7231 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 7232 | |
| 7233 | " refresh the listing |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7234 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7235 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7236 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7237 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7238 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"no files marked!",59) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7239 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7240 | |
| 7241 | else " apply command to global list of files, en bloc |
| 7242 | |
| 7243 | call inputsave() |
| 7244 | let cmd= input("Enter command: ","","file") |
| 7245 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7246 | " call Decho("cmd<".cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7247 | if cmd == "" |
| 7248 | " call Dret("s:NetrwMarkFileExe : early exit, empty command") |
| 7249 | return |
| 7250 | endif |
| 7251 | if cmd =~ '%' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7252 | let cmd= substitute(cmd,'%',join(map(s:netrwmarkfilelist,'s:ShellEscape(v:val)'),' '),'g') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7253 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7254 | let cmd= cmd.' '.join(map(s:netrwmarkfilelist,'s:ShellEscape(v:val)'),' ') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7255 | endif |
| 7256 | if a:islocal |
| 7257 | call system(cmd) |
| 7258 | if v:shell_error < 0 |
| 7259 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"command<".xcmd."> failed, aborting",54) |
| 7260 | endif |
| 7261 | else |
| 7262 | let ret= s:RemoteSystem(cmd) |
| 7263 | endif |
| 7264 | call s:NetrwUnmarkAll() |
| 7265 | |
| 7266 | " refresh the listing |
| 7267 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7268 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7269 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7270 | |
| 7271 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7272 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7273 | " call Dret("s:NetrwMarkFileExe") |
| 7274 | endfun |
| 7275 | |
| 7276 | " --------------------------------------------------------------------- |
| 7277 | " s:NetrwMarkHideSfx: (invoked by mh) (un)hide files having same suffix |
| 7278 | " as the marked file(s) (toggles suffix presence) |
| 7279 | " Uses the local marked file list. |
| 7280 | fun! s:NetrwMarkHideSfx(islocal) |
| 7281 | " call Dfunc("s:NetrwMarkHideSfx(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7282 | let svpos = winsaveview() |
| 7283 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7284 | let curbufnr = bufnr("%") |
| 7285 | |
| 7286 | " s:netrwmarkfilelist_{curbufnr}: the List of marked files |
| 7287 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7288 | |
| 7289 | for fname in s:netrwmarkfilelist_{curbufnr} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7290 | " call Decho("s:NetrwMarkFileCopy: fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7291 | " construct suffix pattern |
| 7292 | if fname =~ '\.' |
| 7293 | let sfxpat= "^.*".substitute(fname,'^.*\(\.[^. ]\+\)$','\1','') |
| 7294 | else |
| 7295 | let sfxpat= '^\%(\%(\.\)\@!.\)*$' |
| 7296 | endif |
| 7297 | " determine if its in the hiding list or not |
| 7298 | let inhidelist= 0 |
| 7299 | if g:netrw_list_hide != "" |
| 7300 | let itemnum = 0 |
| 7301 | let hidelist= split(g:netrw_list_hide,',') |
| 7302 | for hidepat in hidelist |
| 7303 | if sfxpat == hidepat |
| 7304 | let inhidelist= 1 |
| 7305 | break |
| 7306 | endif |
| 7307 | let itemnum= itemnum + 1 |
| 7308 | endfor |
| 7309 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7310 | " call Decho("fname<".fname."> inhidelist=".inhidelist." sfxpat<".sfxpat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7311 | if inhidelist |
| 7312 | " remove sfxpat from list |
| 7313 | call remove(hidelist,itemnum) |
| 7314 | let g:netrw_list_hide= join(hidelist,",") |
| 7315 | elseif g:netrw_list_hide != "" |
| 7316 | " append sfxpat to non-empty list |
| 7317 | let g:netrw_list_hide= g:netrw_list_hide.",".sfxpat |
| 7318 | else |
| 7319 | " set hiding list to sfxpat |
| 7320 | let g:netrw_list_hide= sfxpat |
| 7321 | endif |
| 7322 | endfor |
| 7323 | |
| 7324 | " refresh the listing |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7325 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7326 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7327 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7328 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7329 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"no files marked!",59) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7330 | endif |
| 7331 | |
| 7332 | " call Dret("s:NetrwMarkHideSfx") |
| 7333 | endfun |
| 7334 | |
| 7335 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7336 | " s:NetrwMarkFileVimCmd: (invoked by mv) execute arbitrary vim command on marked files, one at a time {{{2 |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7337 | " Uses the local marked-file list. |
| 7338 | fun! s:NetrwMarkFileVimCmd(islocal) |
| 7339 | " call Dfunc("s:NetrwMarkFileVimCmd(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7340 | let svpos = winsaveview() |
| 7341 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7342 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7343 | let curbufnr = bufnr("%") |
| 7344 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7345 | " sanity check |
| 7346 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7347 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7348 | " call Dret("s:NetrwMarkFileVimCmd") |
| 7349 | return |
| 7350 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7351 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7352 | |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7353 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7354 | " get the command |
| 7355 | call inputsave() |
| 7356 | let cmd= input("Enter vim command: ","","file") |
| 7357 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7358 | " call Decho("cmd<".cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7359 | if cmd == "" |
| 7360 | " " call Dret("s:NetrwMarkFileVimCmd : early exit, empty command") |
| 7361 | return |
| 7362 | endif |
| 7363 | |
| 7364 | " apply command to marked files. Substitute: filename -> % |
| 7365 | " If no %, then append a space and the filename to the command |
| 7366 | for fname in s:netrwmarkfilelist_{curbufnr} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7367 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7368 | if a:islocal |
| 7369 | 1split |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7370 | exe "sil! NetrwKeepj keepalt e ".fnameescape(fname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7371 | " call Decho("local<".fname.">: exe ".cmd,'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7372 | exe cmd |
| 7373 | exe "sil! keepalt wq!" |
| 7374 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7375 | " call Decho("remote<".fname.">: exe ".cmd." : NOT SUPPORTED YET",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7376 | echo "sorry, \"mv\" not supported yet for remote files" |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7377 | endif |
| 7378 | endfor |
| 7379 | |
| 7380 | " unmark marked file list |
| 7381 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 7382 | |
| 7383 | " refresh the listing |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7384 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7385 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7386 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7387 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7388 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"no files marked!",59) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7389 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7390 | |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7391 | " call Dret("s:NetrwMarkFileVimCmd") |
| 7392 | endfun |
| 7393 | |
| 7394 | " --------------------------------------------------------------------- |
| 7395 | " s:NetrwMarkHideSfx: (invoked by mh) (un)hide files having same suffix |
| 7396 | " as the marked file(s) (toggles suffix presence) |
| 7397 | " Uses the local marked file list. |
| 7398 | fun! s:NetrwMarkHideSfx(islocal) |
| 7399 | " call Dfunc("s:NetrwMarkHideSfx(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7400 | let svpos = winsaveview() |
| 7401 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7402 | let curbufnr = bufnr("%") |
| 7403 | |
| 7404 | " s:netrwmarkfilelist_{curbufnr}: the List of marked files |
| 7405 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7406 | |
| 7407 | for fname in s:netrwmarkfilelist_{curbufnr} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7408 | " call Decho("s:NetrwMarkFileCopy: fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7409 | " construct suffix pattern |
| 7410 | if fname =~ '\.' |
| 7411 | let sfxpat= "^.*".substitute(fname,'^.*\(\.[^. ]\+\)$','\1','') |
| 7412 | else |
| 7413 | let sfxpat= '^\%(\%(\.\)\@!.\)*$' |
| 7414 | endif |
| 7415 | " determine if its in the hiding list or not |
| 7416 | let inhidelist= 0 |
| 7417 | if g:netrw_list_hide != "" |
| 7418 | let itemnum = 0 |
| 7419 | let hidelist= split(g:netrw_list_hide,',') |
| 7420 | for hidepat in hidelist |
| 7421 | if sfxpat == hidepat |
| 7422 | let inhidelist= 1 |
| 7423 | break |
| 7424 | endif |
| 7425 | let itemnum= itemnum + 1 |
| 7426 | endfor |
| 7427 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7428 | " call Decho("fname<".fname."> inhidelist=".inhidelist." sfxpat<".sfxpat.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7429 | if inhidelist |
| 7430 | " remove sfxpat from list |
| 7431 | call remove(hidelist,itemnum) |
| 7432 | let g:netrw_list_hide= join(hidelist,",") |
| 7433 | elseif g:netrw_list_hide != "" |
| 7434 | " append sfxpat to non-empty list |
| 7435 | let g:netrw_list_hide= g:netrw_list_hide.",".sfxpat |
| 7436 | else |
| 7437 | " set hiding list to sfxpat |
| 7438 | let g:netrw_list_hide= sfxpat |
| 7439 | endif |
| 7440 | endfor |
| 7441 | |
| 7442 | " refresh the listing |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7443 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7444 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7445 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7446 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7447 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"no files marked!",59) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 7448 | endif |
| 7449 | |
| 7450 | " call Dret("s:NetrwMarkHideSfx") |
| 7451 | endfun |
| 7452 | |
| 7453 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7454 | " s:NetrwMarkFileGrep: (invoked by mg) This function applies vimgrep to marked files {{{2 |
| 7455 | " Uses the global markfilelist |
| 7456 | fun! s:NetrwMarkFileGrep(islocal) |
| 7457 | " call Dfunc("s:NetrwMarkFileGrep(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7458 | let svpos = winsaveview() |
| 7459 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7460 | let curbufnr = bufnr("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7461 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7462 | |
| 7463 | if exists("s:netrwmarkfilelist") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7464 | " call Decho("s:netrwmarkfilelist".string(s:netrwmarkfilelist).">",'~'.expand("<slnum>")) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 7465 | let netrwmarkfilelist= join(map(deepcopy(s:netrwmarkfilelist), "fnameescape(v:val)")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7466 | call s:NetrwUnmarkAll() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7467 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7468 | " call Decho('no marked files, using "*"','~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7469 | let netrwmarkfilelist= "*" |
| 7470 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7471 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7472 | " ask user for pattern |
| 7473 | call inputsave() |
| 7474 | let pat= input("Enter pattern: ","") |
| 7475 | call inputrestore() |
| 7476 | let patbang = "" |
| 7477 | if pat =~ '^!' |
| 7478 | let patbang = "!" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7479 | let pat = strpart(pat,2) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7480 | endif |
| 7481 | if pat =~ '^\i' |
| 7482 | let pat = escape(pat,'/') |
| 7483 | let pat = '/'.pat.'/' |
| 7484 | else |
| 7485 | let nonisi = pat[0] |
| 7486 | endif |
| 7487 | |
| 7488 | " use vimgrep for both local and remote |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7489 | " call Decho("exe vimgrep".patbang." ".pat." ".netrwmarkfilelist,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7490 | try |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7491 | exe "NetrwKeepj noautocmd vimgrep".patbang." ".pat." ".netrwmarkfilelist |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7492 | catch /^Vim\%((\a\+)\)\=:E480/ |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7493 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"no match with pattern<".pat.">",76) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7494 | " call Dret("s:NetrwMarkFileGrep : unable to find pattern<".pat.">") |
| 7495 | return |
| 7496 | endtry |
| 7497 | echo "(use :cn, :cp to navigate, :Rex to return)" |
| 7498 | |
| 7499 | 2match none |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7500 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7501 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7502 | |
| 7503 | if exists("nonisi") |
| 7504 | " original, user-supplied pattern did not begin with a character from isident |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7505 | " call Decho("looking for trailing nonisi<".nonisi."> followed by a j, gj, or jg",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7506 | if pat =~# nonisi.'j$\|'.nonisi.'gj$\|'.nonisi.'jg$' |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7507 | call s:NetrwMarkFileQFEL(a:islocal,getqflist()) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7508 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7509 | endif |
| 7510 | |
| 7511 | " call Dret("s:NetrwMarkFileGrep") |
| 7512 | endfun |
| 7513 | |
| 7514 | " --------------------------------------------------------------------- |
| 7515 | " s:NetrwMarkFileMove: (invoked by mm) execute arbitrary command on marked files, one at a time {{{2 |
| 7516 | " uses the global marked file list |
| 7517 | " s:netrwmfloc= 0: target directory is remote |
| 7518 | " = 1: target directory is local |
| 7519 | fun! s:NetrwMarkFileMove(islocal) |
| 7520 | " call Dfunc("s:NetrwMarkFileMove(islocal=".a:islocal.")") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7521 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7522 | let curbufnr = bufnr("%") |
| 7523 | |
| 7524 | " sanity check |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7525 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7526 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7527 | " call Dret("s:NetrwMarkFileMove") |
| 7528 | return |
| 7529 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7530 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7531 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7532 | if !exists("s:netrwmftgt") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7533 | NetrwKeepj call netrw#ErrorMsg(2,"your marked file target is empty! (:help netrw-mt)",67) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7534 | " call Dret("s:NetrwMarkFileCopy 0") |
| 7535 | return 0 |
| 7536 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7537 | " call Decho("sanity chk passed: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7538 | |
| 7539 | if a:islocal && s:netrwmftgt_islocal |
| 7540 | " move: local -> local |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7541 | " call Decho("move from local to local",'~'.expand("<slnum>")) |
| 7542 | " call Decho("local to local move",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7543 | if !executable(g:netrw_localmovecmd) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7544 | call netrw#ErrorMsg(s:ERROR,"g:netrw_localmovecmd<".g:netrw_localmovecmd."> not executable on your system, aborting",90) |
| 7545 | " call Dfunc("s:NetrwMarkFileMove : g:netrw_localmovecmd<".g:netrw_localmovecmd."> n/a!") |
| 7546 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7547 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7548 | let tgt = s:ShellEscape(s:netrwmftgt) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7549 | " call Decho("tgt<".tgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7550 | if !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7551 | let tgt= substitute(tgt, '/','\\','g') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7552 | " call Decho("windows exception: tgt<".tgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7553 | if g:netrw_localmovecmd =~ '\s' |
| 7554 | let movecmd = substitute(g:netrw_localmovecmd,'\s.*$','','') |
| 7555 | let movecmdargs = substitute(g:netrw_localmovecmd,'^.\{-}\(\s.*\)$','\1','') |
| 7556 | let movecmd = netrw#WinPath(movecmd).movecmdargs |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7557 | " call Decho("windows exception: movecmd<".movecmd."> (#1: had a space)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7558 | else |
| 7559 | let movecmd = netrw#WinPath(movecmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7560 | " call Decho("windows exception: movecmd<".movecmd."> (#2: no space)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7561 | endif |
| 7562 | else |
| 7563 | let movecmd = netrw#WinPath(g:netrw_localmovecmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7564 | " call Decho("movecmd<".movecmd."> (#3 linux or cygwin)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7565 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7566 | for fname in s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7567 | if !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 7568 | let fname= substitute(fname,'/','\\','g') |
| 7569 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7570 | " call Decho("system(".movecmd." ".s:ShellEscape(fname)." ".tgt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7571 | let ret= system(movecmd.g:netrw_localmovecmdopt." ".s:ShellEscape(fname)." ".tgt) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7572 | if v:shell_error != 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7573 | if exists("b:netrw_curdir") && b:netrw_curdir != getcwd() && !g:netrw_keepdir |
| 7574 | call netrw#ErrorMsg(s:ERROR,"move failed; perhaps due to vim's current directory<".getcwd()."> not matching netrw's (".b:netrw_curdir.") (see :help netrw-c)",100) |
| 7575 | else |
| 7576 | call netrw#ErrorMsg(s:ERROR,"tried using g:netrw_localmovecmd<".g:netrw_localmovecmd.">; it doesn't work!",54) |
| 7577 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7578 | break |
| 7579 | endif |
| 7580 | endfor |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7581 | |
| 7582 | elseif a:islocal && !s:netrwmftgt_islocal |
| 7583 | " move: local -> remote |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7584 | " call Decho("move from local to remote",'~'.expand("<slnum>")) |
| 7585 | " call Decho("copy",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7586 | let mflist= s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7587 | NetrwKeepj call s:NetrwMarkFileCopy(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7588 | " call Decho("remove",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7589 | for fname in mflist |
| 7590 | let barefname = substitute(fname,'^\(.*/\)\(.\{-}\)$','\2','') |
| 7591 | let ok = s:NetrwLocalRmFile(b:netrw_curdir,barefname,1) |
| 7592 | endfor |
| 7593 | unlet mflist |
| 7594 | |
| 7595 | elseif !a:islocal && s:netrwmftgt_islocal |
| 7596 | " move: remote -> local |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7597 | " call Decho("move from remote to local",'~'.expand("<slnum>")) |
| 7598 | " call Decho("copy",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7599 | let mflist= s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7600 | NetrwKeepj call s:NetrwMarkFileCopy(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7601 | " call Decho("remove",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7602 | for fname in mflist |
| 7603 | let barefname = substitute(fname,'^\(.*/\)\(.\{-}\)$','\2','') |
| 7604 | let ok = s:NetrwRemoteRmFile(b:netrw_curdir,barefname,1) |
| 7605 | endfor |
| 7606 | unlet mflist |
| 7607 | |
| 7608 | elseif !a:islocal && !s:netrwmftgt_islocal |
| 7609 | " move: remote -> remote |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7610 | " call Decho("move from remote to remote",'~'.expand("<slnum>")) |
| 7611 | " call Decho("copy",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7612 | let mflist= s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7613 | NetrwKeepj call s:NetrwMarkFileCopy(a:islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7614 | " call Decho("remove",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7615 | for fname in mflist |
| 7616 | let barefname = substitute(fname,'^\(.*/\)\(.\{-}\)$','\2','') |
| 7617 | let ok = s:NetrwRemoteRmFile(b:netrw_curdir,barefname,1) |
| 7618 | endfor |
| 7619 | unlet mflist |
| 7620 | endif |
| 7621 | |
| 7622 | " ------- |
| 7623 | " cleanup |
| 7624 | " ------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7625 | " call Decho("cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7626 | |
| 7627 | " remove markings from local buffer |
| 7628 | call s:NetrwUnmarkList(curbufnr,curdir) " remove markings from local buffer |
| 7629 | |
| 7630 | " refresh buffers |
| 7631 | if !s:netrwmftgt_islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7632 | " call Decho("refresh netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7633 | NetrwKeepj call s:NetrwRefreshDir(s:netrwmftgt_islocal,s:netrwmftgt) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7634 | endif |
| 7635 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7636 | " call Decho("refresh b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7637 | NetrwKeepj call s:NetrwRefreshDir(a:islocal,b:netrw_curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7638 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7639 | if g:netrw_fastbrowse <= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7640 | " call Decho("since g:netrw_fastbrowse=".g:netrw_fastbrowse.", perform shell cmd refresh",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7641 | NetrwKeepj call s:LocalBrowseRefresh() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7642 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7643 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7644 | " call Dret("s:NetrwMarkFileMove") |
| 7645 | endfun |
| 7646 | |
| 7647 | " --------------------------------------------------------------------- |
| 7648 | " s:NetrwMarkFilePrint: (invoked by mp) This function prints marked files {{{2 |
| 7649 | " using the hardcopy command. Local marked-file list only. |
| 7650 | fun! s:NetrwMarkFilePrint(islocal) |
| 7651 | " call Dfunc("s:NetrwMarkFilePrint(islocal=".a:islocal.")") |
| 7652 | let curbufnr= bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7653 | |
| 7654 | " sanity check |
| 7655 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7656 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7657 | " call Dret("s:NetrwMarkFilePrint") |
| 7658 | return |
| 7659 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7660 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
| 7661 | let curdir= s:NetrwGetCurdir(a:islocal) |
| 7662 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7663 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7664 | let netrwmarkfilelist = s:netrwmarkfilelist_{curbufnr} |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7665 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 7666 | for fname in netrwmarkfilelist |
| 7667 | if a:islocal |
| 7668 | if g:netrw_keepdir |
| 7669 | let fname= s:ComposePath(curdir,fname) |
| 7670 | endif |
| 7671 | else |
| 7672 | let fname= curdir.fname |
| 7673 | endif |
| 7674 | 1split |
| 7675 | " the autocmds will handle both local and remote files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7676 | " call Decho("exe sil e ".escape(fname,' '),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7677 | exe "sil NetrwKeepj e ".fnameescape(fname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7678 | " call Decho("hardcopy",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7679 | hardcopy |
| 7680 | q |
| 7681 | endfor |
| 7682 | 2match none |
| 7683 | endif |
| 7684 | " call Dret("s:NetrwMarkFilePrint") |
| 7685 | endfun |
| 7686 | |
| 7687 | " --------------------------------------------------------------------- |
| 7688 | " s:NetrwMarkFileRegexp: (invoked by mr) This function is used to mark {{{2 |
| 7689 | " files when given a regexp (for which a prompt is |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7690 | " issued) (matches to name of files). |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7691 | fun! s:NetrwMarkFileRegexp(islocal) |
| 7692 | " call Dfunc("s:NetrwMarkFileRegexp(islocal=".a:islocal.")") |
| 7693 | |
| 7694 | " get the regular expression |
| 7695 | call inputsave() |
| 7696 | let regexp= input("Enter regexp: ","","file") |
| 7697 | call inputrestore() |
| 7698 | |
| 7699 | if a:islocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7700 | let curdir= s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7701 | " get the matching list of files using local glob() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7702 | " call Decho("handle local regexp",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7703 | let dirname = escape(b:netrw_curdir,g:netrw_glob_escape) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7704 | if v:version > 704 || (v:version == 704 && has("patch656")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7705 | let files = glob(s:ComposePath(dirname,regexp),0,0,1) |
| 7706 | else |
| 7707 | let files = glob(s:ComposePath(dirname,regexp),0,0) |
| 7708 | endif |
| 7709 | " call Decho("files<".files.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7710 | let filelist= split(files,"\n") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7711 | |
| 7712 | " mark the list of files |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7713 | for fname in filelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7714 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7715 | NetrwKeepj call s:NetrwMarkFile(a:islocal,substitute(fname,'^.*/','','')) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7716 | endfor |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7717 | |
| 7718 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7719 | " call Decho("handle remote regexp",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7720 | |
| 7721 | " convert displayed listing into a filelist |
| 7722 | let eikeep = &ei |
| 7723 | let areg = @a |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7724 | sil NetrwKeepj %y a |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7725 | setl ei=all ma |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7726 | " call Decho("setl ei=all ma",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7727 | 1split |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7728 | NetrwKeepj call s:NetrwEnew() |
| 7729 | NetrwKeepj call s:NetrwSafeOptions() |
| 7730 | sil NetrwKeepj norm! "ap |
| 7731 | NetrwKeepj 2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7732 | let bannercnt= search('^" =====','W') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7733 | exe "sil NetrwKeepj 1,".bannercnt."d" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7734 | setl bt=nofile |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7735 | if g:netrw_liststyle == s:LONGLIST |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7736 | sil NetrwKeepj %s/\s\{2,}\S.*$//e |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7737 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7738 | elseif g:netrw_liststyle == s:WIDELIST |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7739 | sil NetrwKeepj %s/\s\{2,}/\r/ge |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7740 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7741 | elseif g:netrw_liststyle == s:TREELIST |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7742 | exe 'sil NetrwKeepj %s/^'.s:treedepthstring.' //e' |
| 7743 | sil! NetrwKeepj g/^ .*$/d |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7744 | call histdel("/",-1) |
| 7745 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7746 | endif |
| 7747 | " convert regexp into the more usual glob-style format |
| 7748 | let regexp= substitute(regexp,'\*','.*','g') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7749 | " call Decho("regexp<".regexp.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7750 | exe "sil! NetrwKeepj v/".escape(regexp,'/')."/d" |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7751 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7752 | let filelist= getline(1,line("$")) |
| 7753 | q! |
| 7754 | for filename in filelist |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7755 | NetrwKeepj call s:NetrwMarkFile(a:islocal,substitute(filename,'^.*/','','')) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7756 | endfor |
| 7757 | unlet filelist |
| 7758 | let @a = areg |
| 7759 | let &ei = eikeep |
| 7760 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7761 | echo " (use me to edit marked files)" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7762 | |
| 7763 | " call Dret("s:NetrwMarkFileRegexp") |
| 7764 | endfun |
| 7765 | |
| 7766 | " --------------------------------------------------------------------- |
| 7767 | " s:NetrwMarkFileSource: (invoked by ms) This function sources marked files {{{2 |
| 7768 | " Uses the local marked file list. |
| 7769 | fun! s:NetrwMarkFileSource(islocal) |
| 7770 | " call Dfunc("s:NetrwMarkFileSource(islocal=".a:islocal.")") |
| 7771 | let curbufnr= bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7772 | |
| 7773 | " sanity check |
| 7774 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7775 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7776 | " call Dret("s:NetrwMarkFileSource") |
| 7777 | return |
| 7778 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7779 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
| 7780 | let curdir= s:NetrwGetCurdir(a:islocal) |
| 7781 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7782 | if exists("s:netrwmarkfilelist_{curbufnr}") |
| 7783 | let netrwmarkfilelist = s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7784 | call s:NetrwUnmarkList(curbufnr,curdir) |
| 7785 | for fname in netrwmarkfilelist |
| 7786 | if a:islocal |
| 7787 | if g:netrw_keepdir |
| 7788 | let fname= s:ComposePath(curdir,fname) |
| 7789 | endif |
| 7790 | else |
| 7791 | let fname= curdir.fname |
| 7792 | endif |
| 7793 | " the autocmds will handle sourcing both local and remote files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7794 | " call Decho("exe so ".fnameescape(fname),'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7795 | exe "so ".fnameescape(fname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7796 | endfor |
| 7797 | 2match none |
| 7798 | endif |
| 7799 | " call Dret("s:NetrwMarkFileSource") |
| 7800 | endfun |
| 7801 | |
| 7802 | " --------------------------------------------------------------------- |
| 7803 | " s:NetrwMarkFileTag: (invoked by mT) This function applies g:netrw_ctags to marked files {{{2 |
| 7804 | " Uses the global markfilelist |
| 7805 | fun! s:NetrwMarkFileTag(islocal) |
| 7806 | " call Dfunc("s:NetrwMarkFileTag(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7807 | let svpos = winsaveview() |
| 7808 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7809 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7810 | let curbufnr = bufnr("%") |
| 7811 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7812 | " sanity check |
| 7813 | if !exists("s:netrwmarkfilelist_{curbufnr}") || empty(s:netrwmarkfilelist_{curbufnr}) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7814 | NetrwKeepj call netrw#ErrorMsg(2,"there are no marked files in this window (:help netrw-mf)",66) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7815 | " call Dret("s:NetrwMarkFileTag") |
| 7816 | return |
| 7817 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7818 | " call Decho("sanity chk passed: s:netrwmarkfilelist_".curbufnr."<".string(s:netrwmarkfilelist_{curbufnr}),'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7819 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7820 | if exists("s:netrwmarkfilelist") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7821 | " call Decho("s:netrwmarkfilelist".string(s:netrwmarkfilelist).">",'~'.expand("<slnum>")) |
| 7822 | let netrwmarkfilelist= join(map(deepcopy(s:netrwmarkfilelist), "s:ShellEscape(v:val,".!a:islocal.")")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7823 | call s:NetrwUnmarkAll() |
| 7824 | |
| 7825 | if a:islocal |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7826 | |
| 7827 | " call Decho("call system(".g:netrw_ctags." ".netrwmarkfilelist.")",'~'.expand("<slnum>")) |
| 7828 | call system(g:netrw_ctags." ".netrwmarkfilelist) |
| 7829 | if v:shell_error |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7830 | call netrw#ErrorMsg(s:ERROR,"g:netrw_ctags<".g:netrw_ctags."> is not executable!",51) |
| 7831 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 7832 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7833 | else |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7834 | let cmd = s:RemoteSystem(g:netrw_ctags." ".netrwmarkfilelist) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7835 | call netrw#Obtain(a:islocal,"tags") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7836 | let curdir= b:netrw_curdir |
| 7837 | 1split |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7838 | NetrwKeepj e tags |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7839 | let path= substitute(curdir,'^\(.*\)/[^/]*$','\1/','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7840 | " call Decho("curdir<".curdir."> path<".path.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7841 | exe 'NetrwKeepj %s/\t\(\S\+\)\t/\t'.escape(path,"/\n\r\\").'\1\t/e' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7842 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7843 | wq! |
| 7844 | endif |
| 7845 | 2match none |
| 7846 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7847 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7848 | call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7849 | endif |
| 7850 | |
| 7851 | " call Dret("s:NetrwMarkFileTag") |
| 7852 | endfun |
| 7853 | |
| 7854 | " --------------------------------------------------------------------- |
| 7855 | " s:NetrwMarkFileTgt: (invoked by mt) This function sets up a marked file target {{{2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7856 | " Sets up two variables, |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7857 | " s:netrwmftgt : holds the target directory |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7858 | " s:netrwmftgt_islocal : 0=target directory is remote |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7859 | " 1=target directory is local |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7860 | fun! s:NetrwMarkFileTgt(islocal) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7861 | " call Dfunc("s:NetrwMarkFileTgt(islocal=".a:islocal.")") |
| 7862 | let svpos = winsaveview() |
| 7863 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7864 | let curdir = s:NetrwGetCurdir(a:islocal) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7865 | let hadtgt = exists("s:netrwmftgt") |
| 7866 | if !exists("w:netrw_bannercnt") |
| 7867 | let w:netrw_bannercnt= b:netrw_bannercnt |
| 7868 | endif |
| 7869 | |
| 7870 | " set up target |
| 7871 | if line(".") < w:netrw_bannercnt |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7872 | " call Decho("set up target: line(.) < w:netrw_bannercnt=".w:netrw_bannercnt,'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7873 | " if cursor in banner region, use b:netrw_curdir for the target unless its already the target |
| 7874 | if exists("s:netrwmftgt") && exists("s:netrwmftgt_islocal") && s:netrwmftgt == b:netrw_curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7875 | " call Decho("cursor in banner region, and target already is <".b:netrw_curdir.">: removing target",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7876 | unlet s:netrwmftgt s:netrwmftgt_islocal |
| 7877 | if g:netrw_fastbrowse <= 1 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7878 | call s:LocalBrowseRefresh() |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7879 | endif |
| 7880 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7881 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7882 | call winrestview(svpos) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7883 | " call Dret("s:NetrwMarkFileTgt : removed target") |
| 7884 | return |
| 7885 | else |
| 7886 | let s:netrwmftgt= b:netrw_curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7887 | " call Decho("inbanner: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 7888 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7889 | |
| 7890 | else |
| 7891 | " get word under cursor. |
| 7892 | " * If directory, use it for the target. |
| 7893 | " * If file, use b:netrw_curdir for the target |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7894 | " call Decho("get word under cursor",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7895 | let curword= s:NetrwGetWord() |
| 7896 | let tgtdir = s:ComposePath(curdir,curword) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7897 | if a:islocal && isdirectory(s:NetrwFile(tgtdir)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7898 | let s:netrwmftgt = tgtdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7899 | " call Decho("local isdir: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7900 | elseif !a:islocal && tgtdir =~ '/$' |
| 7901 | let s:netrwmftgt = tgtdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7902 | " call Decho("remote isdir: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7903 | else |
| 7904 | let s:netrwmftgt = curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7905 | " call Decho("isfile: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7906 | endif |
| 7907 | endif |
| 7908 | if a:islocal |
| 7909 | " simplify the target (eg. /abc/def/../ghi -> /abc/ghi) |
| 7910 | let s:netrwmftgt= simplify(s:netrwmftgt) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7911 | " call Decho("simplify: s:netrwmftgt<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7912 | endif |
| 7913 | if g:netrw_cygwin |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7914 | let s:netrwmftgt= substitute(system("cygpath ".s:ShellEscape(s:netrwmftgt)),'\n$','','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7915 | let s:netrwmftgt= substitute(s:netrwmftgt,'\n$','','') |
| 7916 | endif |
| 7917 | let s:netrwmftgt_islocal= a:islocal |
| 7918 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7919 | " need to do refresh so that the banner will be updated |
| 7920 | " s:LocalBrowseRefresh handles all local-browsing buffers when not fast browsing |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 7921 | if g:netrw_fastbrowse <= 1 |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7922 | " call Decho("g:netrw_fastbrowse=".g:netrw_fastbrowse.", so refreshing all local netrw buffers",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 7923 | call s:LocalBrowseRefresh() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7924 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7925 | " call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7926 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7927 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,w:netrw_treetop)) |
| 7928 | else |
| 7929 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 7930 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7931 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 7932 | call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7933 | if !hadtgt |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7934 | sil! NetrwKeepj norm! j |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7935 | endif |
| 7936 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7937 | " call Decho("getmatches=".string(getmatches()),'~'.expand("<slnum>")) |
| 7938 | " call Decho("s:netrwmarkfilelist=".(exists("s:netrwmarkfilelist")? string(s:netrwmarkfilelist) : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 7939 | " call Dret("s:NetrwMarkFileTgt : netrwmftgt<".(exists("s:netrwmftgt")? s:netrwmftgt : "").">") |
| 7940 | endfun |
| 7941 | |
| 7942 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7943 | " s:NetrwGetCurdir: gets current directory and sets up b:netrw_curdir if necessary {{{2 |
| 7944 | fun! s:NetrwGetCurdir(islocal) |
| 7945 | " call Dfunc("s:NetrwGetCurdir(islocal=".a:islocal.")") |
| 7946 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7947 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7948 | let b:netrw_curdir = s:NetrwTreePath(w:netrw_treetop) |
| 7949 | " call Decho("set b:netrw_curdir<".b:netrw_curdir."> (used s:NetrwTreeDir)",'~'.expand("<slnum>")) |
| 7950 | elseif !exists("b:netrw_curdir") |
| 7951 | let b:netrw_curdir= getcwd() |
| 7952 | " call Decho("set b:netrw_curdir<".b:netrw_curdir."> (used getcwd)",'~'.expand("<slnum>")) |
| 7953 | endif |
| 7954 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7955 | " call Decho("b:netrw_curdir<".b:netrw_curdir."> ".((b:netrw_curdir !~ '\<\a\{3,}://')? "does not match" : "matches")." url pattern",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7956 | if b:netrw_curdir !~ '\<\a\{3,}://' |
| 7957 | let curdir= b:netrw_curdir |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 7958 | " call Decho("g:netrw_keepdir=".g:netrw_keepdir,'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7959 | if g:netrw_keepdir == 0 |
| 7960 | call s:NetrwLcd(curdir) |
| 7961 | endif |
| 7962 | endif |
| 7963 | |
| 7964 | " call Dret("s:NetrwGetCurdir <".curdir.">") |
| 7965 | return b:netrw_curdir |
| 7966 | endfun |
| 7967 | |
| 7968 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7969 | " s:NetrwOpenFile: query user for a filename and open it {{{2 |
| 7970 | fun! s:NetrwOpenFile(islocal) |
| 7971 | " call Dfunc("s:NetrwOpenFile(islocal=".a:islocal.")") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7972 | let ykeep= @@ |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7973 | call inputsave() |
| 7974 | let fname= input("Enter filename: ") |
| 7975 | call inputrestore() |
| 7976 | if fname !~ '[/\\]' |
| 7977 | if exists("b:netrw_curdir") |
| 7978 | if exists("g:netrw_quiet") |
| 7979 | let netrw_quiet_keep = g:netrw_quiet |
| 7980 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 7981 | let g:netrw_quiet = 1 |
| 7982 | " save position for benefit of Rexplore |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 7983 | let s:rexposn_{bufnr("%")}= winsaveview() |
| 7984 | " call Decho("saving posn to s:rexposn_".bufnr("%")."<".string(s:rexposn_{bufnr("%")}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7985 | if b:netrw_curdir =~ '/$' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7986 | exe "NetrwKeepj e ".fnameescape(b:netrw_curdir.fname) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7987 | else |
| 7988 | exe "e ".fnameescape(b:netrw_curdir."/".fname) |
| 7989 | endif |
| 7990 | if exists("netrw_quiet_keep") |
| 7991 | let g:netrw_quiet= netrw_quiet_keep |
| 7992 | else |
| 7993 | unlet g:netrw_quiet |
| 7994 | endif |
| 7995 | endif |
| 7996 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 7997 | exe "NetrwKeepj e ".fnameescape(fname) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 7998 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 7999 | let @@= ykeep |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 8000 | " call Dret("s:NetrwOpenFile") |
| 8001 | endfun |
| 8002 | |
| 8003 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8004 | " netrw#Shrink: shrinks/expands a netrw or Lexplorer window {{{2 |
| 8005 | " For the mapping to this function be made via |
| 8006 | " netrwPlugin, you'll need to have had |
| 8007 | " g:netrw_usetab set to non-zero. |
| 8008 | fun! netrw#Shrink() |
| 8009 | " call Dfunc("netrw#Shrink() ft<".&ft."> winwidth=".winwidth(0)." lexbuf#".((exists("t:netrw_lexbufnr"))? t:netrw_lexbufnr : 'n/a')) |
| 8010 | let curwin = winnr() |
| 8011 | let wiwkeep = &wiw |
| 8012 | set wiw=1 |
| 8013 | |
| 8014 | if &ft == "netrw" |
| 8015 | if winwidth(0) > g:netrw_wiw |
| 8016 | let t:netrw_winwidth= winwidth(0) |
| 8017 | exe "vert resize ".g:netrw_wiw |
| 8018 | wincmd l |
| 8019 | if winnr() == curwin |
| 8020 | wincmd h |
| 8021 | endif |
| 8022 | " call Decho("vert resize 0",'~'.expand("<slnum>")) |
| 8023 | else |
| 8024 | exe "vert resize ".t:netrw_winwidth |
| 8025 | " call Decho("vert resize ".t:netrw_winwidth,'~'.expand("<slnum>")) |
| 8026 | endif |
| 8027 | |
| 8028 | elseif exists("t:netrw_lexbufnr") |
| 8029 | exe bufwinnr(t:netrw_lexbufnr)."wincmd w" |
| 8030 | if winwidth(bufwinnr(t:netrw_lexbufnr)) > g:netrw_wiw |
| 8031 | let t:netrw_winwidth= winwidth(0) |
| 8032 | exe "vert resize ".g:netrw_wiw |
| 8033 | wincmd l |
| 8034 | if winnr() == curwin |
| 8035 | wincmd h |
| 8036 | endif |
| 8037 | " call Decho("vert resize 0",'~'.expand("<slnum>")) |
| 8038 | elseif winwidth(bufwinnr(t:netrw_lexbufnr)) >= 0 |
| 8039 | exe "vert resize ".t:netrw_winwidth |
| 8040 | " call Decho("vert resize ".t:netrw_winwidth,'~'.expand("<slnum>")) |
| 8041 | else |
| 8042 | call netrw#Lexplore(0,0) |
| 8043 | endif |
| 8044 | |
| 8045 | else |
| 8046 | call netrw#Lexplore(0,0) |
| 8047 | endif |
| 8048 | let wiw= wiwkeep |
| 8049 | |
| 8050 | " call Dret("netrw#Shrink") |
| 8051 | endfun |
| 8052 | |
| 8053 | " --------------------------------------------------------------------- |
| 8054 | " s:NetSortSequence: allows user to edit the sorting sequence {{{2 |
| 8055 | fun! s:NetSortSequence(islocal) |
| 8056 | " call Dfunc("NetSortSequence(islocal=".a:islocal.")") |
| 8057 | |
| 8058 | let ykeep= @@ |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8059 | let svpos= winsaveview() |
| 8060 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8061 | call inputsave() |
| 8062 | let newsortseq= input("Edit Sorting Sequence: ",g:netrw_sort_sequence) |
| 8063 | call inputrestore() |
| 8064 | |
| 8065 | " refresh the listing |
| 8066 | let g:netrw_sort_sequence= newsortseq |
| 8067 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8068 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 8069 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8070 | let @@= ykeep |
| 8071 | |
| 8072 | " call Dret("NetSortSequence") |
| 8073 | endfun |
| 8074 | |
| 8075 | " --------------------------------------------------------------------- |
| 8076 | " s:NetrwUnmarkList: delete local marked file list and remove their contents from the global marked-file list {{{2 |
| 8077 | " User access provided by the <mF> mapping. (see :help netrw-mF) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8078 | " Used by many MarkFile functions. |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8079 | fun! s:NetrwUnmarkList(curbufnr,curdir) |
| 8080 | " call Dfunc("s:NetrwUnmarkList(curbufnr=".a:curbufnr." curdir<".a:curdir.">)") |
| 8081 | |
| 8082 | " remove all files in local marked-file list from global list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8083 | if exists("s:netrwmarkfilelist") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8084 | for mfile in s:netrwmarkfilelist_{a:curbufnr} |
| 8085 | let dfile = s:ComposePath(a:curdir,mfile) " prepend directory to mfile |
| 8086 | let idx = index(s:netrwmarkfilelist,dfile) " get index in list of dfile |
| 8087 | call remove(s:netrwmarkfilelist,idx) " remove from global list |
| 8088 | endfor |
| 8089 | if s:netrwmarkfilelist == [] |
| 8090 | unlet s:netrwmarkfilelist |
| 8091 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8092 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8093 | " getting rid of the local marked-file lists is easy |
| 8094 | unlet s:netrwmarkfilelist_{a:curbufnr} |
| 8095 | endif |
| 8096 | if exists("s:netrwmarkfilemtch_{a:curbufnr}") |
| 8097 | unlet s:netrwmarkfilemtch_{a:curbufnr} |
| 8098 | endif |
| 8099 | 2match none |
| 8100 | " call Dret("s:NetrwUnmarkList") |
| 8101 | endfun |
| 8102 | |
| 8103 | " --------------------------------------------------------------------- |
| 8104 | " s:NetrwUnmarkAll: remove the global marked file list and all local ones {{{2 |
| 8105 | fun! s:NetrwUnmarkAll() |
| 8106 | " call Dfunc("s:NetrwUnmarkAll()") |
| 8107 | if exists("s:netrwmarkfilelist") |
| 8108 | unlet s:netrwmarkfilelist |
| 8109 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 8110 | sil call s:NetrwUnmarkAll2() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8111 | 2match none |
| 8112 | " call Dret("s:NetrwUnmarkAll") |
| 8113 | endfun |
| 8114 | |
| 8115 | " --------------------------------------------------------------------- |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8116 | " s:NetrwUnmarkAll2: unmark all files from all buffers {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8117 | fun! s:NetrwUnmarkAll2() |
| 8118 | " call Dfunc("s:NetrwUnmarkAll2()") |
| 8119 | redir => netrwmarkfilelist_let |
| 8120 | let |
| 8121 | redir END |
| 8122 | let netrwmarkfilelist_list= split(netrwmarkfilelist_let,'\n') " convert let string into a let list |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8123 | call filter(netrwmarkfilelist_list,"v:val =~ '^s:netrwmarkfilelist_'") " retain only those vars that start as s:netrwmarkfilelist_ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8124 | call map(netrwmarkfilelist_list,"substitute(v:val,'\\s.*$','','')") " remove what the entries are equal to |
| 8125 | for flist in netrwmarkfilelist_list |
| 8126 | let curbufnr= substitute(flist,'s:netrwmarkfilelist_','','') |
| 8127 | unlet s:netrwmarkfilelist_{curbufnr} |
| 8128 | unlet s:netrwmarkfilemtch_{curbufnr} |
| 8129 | endfor |
| 8130 | " call Dret("s:NetrwUnmarkAll2") |
| 8131 | endfun |
| 8132 | |
| 8133 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8134 | " s:NetrwUnMarkFile: called via mu map; unmarks *all* marked files, both global and buffer-local {{{2 |
| 8135 | " |
| 8136 | " Marked files are in two types of lists: |
| 8137 | " s:netrwmarkfilelist -- holds complete paths to all marked files |
| 8138 | " s:netrwmarkfilelist_# -- holds list of marked files in current-buffer's directory (#==bufnr()) |
| 8139 | " |
| 8140 | " Marked files suitable for use with 2match are in: |
| 8141 | " s:netrwmarkfilemtch_# -- used with 2match to display marked files |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8142 | fun! s:NetrwUnMarkFile(islocal) |
| 8143 | " call Dfunc("s:NetrwUnMarkFile(islocal=".a:islocal.")") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8144 | let svpos = winsaveview() |
| 8145 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8146 | let curbufnr = bufnr("%") |
| 8147 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8148 | " unmark marked file list |
| 8149 | " (although I expect s:NetrwUpload() to do it, I'm just making sure) |
| 8150 | if exists("s:netrwmarkfilelist") |
| 8151 | " " call Decho("unlet'ing: s:netrwmarkfilelist",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8152 | unlet s:netrwmarkfilelist |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8153 | endif |
| 8154 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8155 | let ibuf= 1 |
| 8156 | while ibuf < bufnr("$") |
| 8157 | if exists("s:netrwmarkfilelist_".ibuf) |
| 8158 | unlet s:netrwmarkfilelist_{ibuf} |
| 8159 | unlet s:netrwmarkfilemtch_{ibuf} |
| 8160 | endif |
| 8161 | let ibuf = ibuf + 1 |
| 8162 | endwhile |
| 8163 | 2match none |
| 8164 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8165 | " call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8166 | "call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 8167 | call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8168 | " call Dret("s:NetrwUnMarkFile") |
| 8169 | endfun |
| 8170 | |
| 8171 | " --------------------------------------------------------------------- |
| 8172 | " s:NetrwMenu: generates the menu for gvim and netrw {{{2 |
| 8173 | fun! s:NetrwMenu(domenu) |
| 8174 | |
| 8175 | if !exists("g:NetrwMenuPriority") |
| 8176 | let g:NetrwMenuPriority= 80 |
| 8177 | endif |
| 8178 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 8179 | if has("menu") && has("gui_running") && &go =~# 'm' && g:netrw_menu |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8180 | " call Dfunc("NetrwMenu(domenu=".a:domenu.")") |
| 8181 | |
| 8182 | if !exists("s:netrw_menu_enabled") && a:domenu |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8183 | " call Decho("initialize menu",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8184 | let s:netrw_menu_enabled= 1 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8185 | exe 'sil! menu '.g:NetrwMenuPriority.'.1 '.g:NetrwTopLvlMenu.'Help<tab><F1> <F1>' |
| 8186 | exe 'sil! menu '.g:NetrwMenuPriority.'.5 '.g:NetrwTopLvlMenu.'-Sep1- :' |
| 8187 | exe 'sil! menu '.g:NetrwMenuPriority.'.6 '.g:NetrwTopLvlMenu.'Go\ Up\ Directory<tab>- -' |
| 8188 | exe 'sil! menu '.g:NetrwMenuPriority.'.7 '.g:NetrwTopLvlMenu.'Apply\ Special\ Viewer<tab>x x' |
| 8189 | if g:netrw_dirhistmax > 0 |
| 8190 | exe 'sil! menu '.g:NetrwMenuPriority.'.8.1 '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History.Bookmark\ Current\ Directory<tab>mb mb' |
| 8191 | exe 'sil! menu '.g:NetrwMenuPriority.'.8.4 '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History.Goto\ Prev\ Dir\ (History)<tab>u u' |
| 8192 | exe 'sil! menu '.g:NetrwMenuPriority.'.8.5 '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History.Goto\ Next\ Dir\ (History)<tab>U U' |
| 8193 | exe 'sil! menu '.g:NetrwMenuPriority.'.8.6 '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History.List<tab>qb qb' |
| 8194 | else |
| 8195 | exe 'sil! menu '.g:NetrwMenuPriority.'.8 '.g:NetrwTopLvlMenu.'Bookmarks\ and\ History :echo "(disabled)"'."\<cr>" |
| 8196 | endif |
| 8197 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.1 '.g:NetrwTopLvlMenu.'Browsing\ Control.Horizontal\ Split<tab>o o' |
| 8198 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.2 '.g:NetrwTopLvlMenu.'Browsing\ Control.Vertical\ Split<tab>v v' |
| 8199 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.3 '.g:NetrwTopLvlMenu.'Browsing\ Control.New\ Tab<tab>t t' |
| 8200 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.4 '.g:NetrwTopLvlMenu.'Browsing\ Control.Preview<tab>p p' |
| 8201 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.5 '.g:NetrwTopLvlMenu.'Browsing\ Control.Edit\ File\ Hiding\ List<tab><ctrl-h>'." \<c-h>'" |
| 8202 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.6 '.g:NetrwTopLvlMenu.'Browsing\ Control.Edit\ Sorting\ Sequence<tab>S S' |
| 8203 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.7 '.g:NetrwTopLvlMenu.'Browsing\ Control.Quick\ Hide/Unhide\ Dot\ Files<tab>'."gh gh" |
| 8204 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.8 '.g:NetrwTopLvlMenu.'Browsing\ Control.Refresh\ Listing<tab>'."<ctrl-l> \<c-l>" |
| 8205 | exe 'sil! menu '.g:NetrwMenuPriority.'.9.9 '.g:NetrwTopLvlMenu.'Browsing\ Control.Settings/Options<tab>:NetrwSettings '.":NetrwSettings\<cr>" |
| 8206 | exe 'sil! menu '.g:NetrwMenuPriority.'.10 '.g:NetrwTopLvlMenu.'Delete\ File/Directory<tab>D D' |
| 8207 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.1 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.Create\ New\ File<tab>% %' |
| 8208 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.1 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.In\ Current\ Window<tab><cr> '."\<cr>" |
| 8209 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.2 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.Preview\ File/Directory<tab>p p' |
| 8210 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.3 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.In\ Previous\ Window<tab>P P' |
| 8211 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.4 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.In\ New\ Window<tab>o o' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8212 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.5 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.In\ New\ Tab<tab>t t' |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8213 | exe 'sil! menu '.g:NetrwMenuPriority.'.11.5 '.g:NetrwTopLvlMenu.'Edit\ File/Dir.In\ New\ Vertical\ Window<tab>v v' |
| 8214 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.1 '.g:NetrwTopLvlMenu.'Explore.Directory\ Name :Explore ' |
| 8215 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.2 '.g:NetrwTopLvlMenu.'Explore.Filenames\ Matching\ Pattern\ (curdir\ only)<tab>:Explore\ */ :Explore */' |
| 8216 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.2 '.g:NetrwTopLvlMenu.'Explore.Filenames\ Matching\ Pattern\ (+subdirs)<tab>:Explore\ **/ :Explore **/' |
| 8217 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.3 '.g:NetrwTopLvlMenu.'Explore.Files\ Containing\ String\ Pattern\ (curdir\ only)<tab>:Explore\ *// :Explore *//' |
| 8218 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.4 '.g:NetrwTopLvlMenu.'Explore.Files\ Containing\ String\ Pattern\ (+subdirs)<tab>:Explore\ **// :Explore **//' |
| 8219 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.4 '.g:NetrwTopLvlMenu.'Explore.Next\ Match<tab>:Nexplore :Nexplore<cr>' |
| 8220 | exe 'sil! menu '.g:NetrwMenuPriority.'.12.4 '.g:NetrwTopLvlMenu.'Explore.Prev\ Match<tab>:Pexplore :Pexplore<cr>' |
| 8221 | exe 'sil! menu '.g:NetrwMenuPriority.'.13 '.g:NetrwTopLvlMenu.'Make\ Subdirectory<tab>d d' |
| 8222 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.1 '.g:NetrwTopLvlMenu.'Marked\ Files.Mark\ File<tab>mf mf' |
| 8223 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.2 '.g:NetrwTopLvlMenu.'Marked\ Files.Mark\ Files\ by\ Regexp<tab>mr mr' |
| 8224 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.3 '.g:NetrwTopLvlMenu.'Marked\ Files.Hide-Show-List\ Control<tab>a a' |
| 8225 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.4 '.g:NetrwTopLvlMenu.'Marked\ Files.Copy\ To\ Target<tab>mc mc' |
| 8226 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.5 '.g:NetrwTopLvlMenu.'Marked\ Files.Delete<tab>D D' |
| 8227 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.6 '.g:NetrwTopLvlMenu.'Marked\ Files.Diff<tab>md md' |
| 8228 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.7 '.g:NetrwTopLvlMenu.'Marked\ Files.Edit<tab>me me' |
| 8229 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.8 '.g:NetrwTopLvlMenu.'Marked\ Files.Exe\ Cmd<tab>mx mx' |
| 8230 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.9 '.g:NetrwTopLvlMenu.'Marked\ Files.Move\ To\ Target<tab>mm mm' |
| 8231 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.10 '.g:NetrwTopLvlMenu.'Marked\ Files.Obtain<tab>O O' |
| 8232 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.11 '.g:NetrwTopLvlMenu.'Marked\ Files.Print<tab>mp mp' |
| 8233 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.12 '.g:NetrwTopLvlMenu.'Marked\ Files.Replace<tab>R R' |
| 8234 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.13 '.g:NetrwTopLvlMenu.'Marked\ Files.Set\ Target<tab>mt mt' |
| 8235 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.14 '.g:NetrwTopLvlMenu.'Marked\ Files.Tag<tab>mT mT' |
| 8236 | exe 'sil! menu '.g:NetrwMenuPriority.'.14.15 '.g:NetrwTopLvlMenu.'Marked\ Files.Zip/Unzip/Compress/Uncompress<tab>mz mz' |
| 8237 | exe 'sil! menu '.g:NetrwMenuPriority.'.15 '.g:NetrwTopLvlMenu.'Obtain\ File<tab>O O' |
| 8238 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.1.1 '.g:NetrwTopLvlMenu.'Style.Listing.thin<tab>i :let w:netrw_liststyle=0<cr><c-L>' |
| 8239 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.1.1 '.g:NetrwTopLvlMenu.'Style.Listing.long<tab>i :let w:netrw_liststyle=1<cr><c-L>' |
| 8240 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.1.1 '.g:NetrwTopLvlMenu.'Style.Listing.wide<tab>i :let w:netrw_liststyle=2<cr><c-L>' |
| 8241 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.1.1 '.g:NetrwTopLvlMenu.'Style.Listing.tree<tab>i :let w:netrw_liststyle=3<cr><c-L>' |
| 8242 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.2.1 '.g:NetrwTopLvlMenu.'Style.Normal-Hide-Show.Show\ All<tab>a :let g:netrw_hide=0<cr><c-L>' |
| 8243 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.2.3 '.g:NetrwTopLvlMenu.'Style.Normal-Hide-Show.Normal<tab>a :let g:netrw_hide=1<cr><c-L>' |
| 8244 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.2.2 '.g:NetrwTopLvlMenu.'Style.Normal-Hide-Show.Hidden\ Only<tab>a :let g:netrw_hide=2<cr><c-L>' |
| 8245 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.3 '.g:NetrwTopLvlMenu.'Style.Reverse\ Sorting\ Order<tab>'."r r" |
| 8246 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.4.1 '.g:NetrwTopLvlMenu.'Style.Sorting\ Method.Name<tab>s :let g:netrw_sort_by="name"<cr><c-L>' |
| 8247 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.4.2 '.g:NetrwTopLvlMenu.'Style.Sorting\ Method.Time<tab>s :let g:netrw_sort_by="time"<cr><c-L>' |
| 8248 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.4.3 '.g:NetrwTopLvlMenu.'Style.Sorting\ Method.Size<tab>s :let g:netrw_sort_by="size"<cr><c-L>' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8249 | exe 'sil! menu '.g:NetrwMenuPriority.'.16.4.3 '.g:NetrwTopLvlMenu.'Style.Sorting\ Method.Exten<tab>s :let g:netrw_sort_by="exten"<cr><c-L>' |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8250 | exe 'sil! menu '.g:NetrwMenuPriority.'.17 '.g:NetrwTopLvlMenu.'Rename\ File/Directory<tab>R R' |
| 8251 | exe 'sil! menu '.g:NetrwMenuPriority.'.18 '.g:NetrwTopLvlMenu.'Set\ Current\ Directory<tab>c c' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8252 | let s:netrw_menucnt= 28 |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8253 | call s:NetrwBookmarkMenu() " provide some history! uses priorities 2,3, reserves 4, 8.2.x |
| 8254 | call s:NetrwTgtMenu() " let bookmarks and history be easy targets |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8255 | |
| 8256 | elseif !a:domenu |
| 8257 | let s:netrwcnt = 0 |
| 8258 | let curwin = winnr() |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 8259 | windo if getline(2) =~# "Netrw" | let s:netrwcnt= s:netrwcnt + 1 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8260 | exe curwin."wincmd w" |
| 8261 | |
| 8262 | if s:netrwcnt <= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8263 | " call Decho("clear menus",'~'.expand("<slnum>")) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 8264 | exe 'sil! unmenu '.g:NetrwTopLvlMenu |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8265 | " call Decho('exe sil! unmenu '.g:NetrwTopLvlMenu.'*','~'.expand("<slnum>")) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 8266 | sil! unlet s:netrw_menu_enabled |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8267 | endif |
| 8268 | endif |
| 8269 | " call Dret("NetrwMenu") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8270 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8271 | endif |
| 8272 | |
| 8273 | endfun |
| 8274 | |
| 8275 | " --------------------------------------------------------------------- |
| 8276 | " s:NetrwObtain: obtain file under cursor or from markfile list {{{2 |
| 8277 | " Used by the O maps (as <SID>NetrwObtain()) |
| 8278 | fun! s:NetrwObtain(islocal) |
| 8279 | " call Dfunc("NetrwObtain(islocal=".a:islocal.")") |
| 8280 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8281 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8282 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8283 | let islocal= s:netrwmarkfilelist_{bufnr('%')}[1] !~ '^\a\{3,}://' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8284 | call netrw#Obtain(islocal,s:netrwmarkfilelist_{bufnr('%')}) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8285 | call s:NetrwUnmarkList(bufnr('%'),b:netrw_curdir) |
| 8286 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8287 | call netrw#Obtain(a:islocal,s:NetrwGetWord()) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8288 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8289 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8290 | |
| 8291 | " call Dret("NetrwObtain") |
| 8292 | endfun |
| 8293 | |
| 8294 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8295 | " s:NetrwPrevWinOpen: open file/directory in previous window. {{{2 |
| 8296 | " If there's only one window, then the window will first be split. |
| 8297 | " Returns: |
| 8298 | " choice = 0 : didn't have to choose |
| 8299 | " choice = 1 : saved modified file in window first |
| 8300 | " choice = 2 : didn't save modified file, opened window |
| 8301 | " choice = 3 : cancel open |
| 8302 | fun! s:NetrwPrevWinOpen(islocal) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8303 | " call Dfunc("s:NetrwPrevWinOpen(islocal=".a:islocal.")") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8304 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8305 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8306 | " grab a copy of the b:netrw_curdir to pass it along to newly split windows |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8307 | let curdir = b:netrw_curdir |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8308 | |
| 8309 | " get last window number and the word currently under the cursor |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8310 | let origwin = winnr() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8311 | let lastwinnr = winnr("$") |
| 8312 | let curword = s:NetrwGetWord() |
| 8313 | let choice = 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8314 | let s:treedir = s:NetrwTreeDir(a:islocal) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8315 | let curdir = s:treedir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8316 | " call Decho("winnr($)#".lastwinnr." curword<".curword.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8317 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8318 | let didsplit = 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8319 | if lastwinnr == 1 |
| 8320 | " if only one window, open a new one first |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8321 | " call Decho("only one window, so open a new one (g:netrw_alto=".g:netrw_alto.")",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8322 | " g:netrw_preview=0: preview window shown in a horizontally split window |
| 8323 | " g:netrw_preview=1: preview window shown in a vertically split window |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8324 | if g:netrw_preview |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8325 | " vertically split preview window |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8326 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winwidth(0))/100 : -g:netrw_winsize |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8327 | " call Decho("exe ".(g:netrw_alto? "top " : "bot ")."vert ".winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8328 | exe (g:netrw_alto? "top " : "bot ")."vert ".winsz."wincmd s" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8329 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8330 | " horizontally split preview window |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8331 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winheight(0))/100 : -g:netrw_winsize |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8332 | " call Decho("exe ".(g:netrw_alto? "bel " : "abo ").winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8333 | exe (g:netrw_alto? "bel " : "abo ").winsz."wincmd s" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8334 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8335 | let didsplit = 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8336 | " call Decho("did split",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8337 | |
| 8338 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8339 | NetrwKeepj call s:SaveBufVars() |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8340 | let eikeep= &ei |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8341 | setl ei=all |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8342 | wincmd p |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8343 | " call Decho("wincmd p (now in win#".winnr().") curdir<".curdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8344 | |
| 8345 | " prevwinnr: the window number of the "prev" window |
| 8346 | " prevbufnr: the buffer number of the buffer in the "prev" window |
| 8347 | " bnrcnt : the qty of windows open on the "prev" buffer |
| 8348 | let prevwinnr = winnr() |
| 8349 | let prevbufnr = bufnr("%") |
| 8350 | let prevbufname = bufname("%") |
| 8351 | let prevmod = &mod |
| 8352 | let bnrcnt = 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8353 | NetrwKeepj call s:RestoreBufVars() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8354 | " call Decho("after wincmd p: win#".winnr()." win($)#".winnr("$")." origwin#".origwin." &mod=".&mod." bufname(%)<".bufname("%")."> prevbufnr=".prevbufnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8355 | |
| 8356 | " if the previous window's buffer has been changed (ie. its modified flag is set), |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8357 | " and it doesn't appear in any other extant window, then ask the |
| 8358 | " user if s/he wants to abandon modifications therein. |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8359 | if prevmod |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8360 | " call Decho("detected that prev window's buffer has been modified: prevbufnr=".prevbufnr." winnr()#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8361 | windo if winbufnr(0) == prevbufnr | let bnrcnt=bnrcnt+1 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8362 | " call Decho("prevbufnr=".prevbufnr." bnrcnt=".bnrcnt." buftype=".&bt." winnr()=".winnr()." prevwinnr#".prevwinnr,'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8363 | exe prevwinnr."wincmd w" |
| 8364 | |
| 8365 | if bnrcnt == 1 && &hidden == 0 |
| 8366 | " only one copy of the modified buffer in a window, and |
| 8367 | " hidden not set, so overwriting will lose the modified file. Ask first... |
| 8368 | let choice = confirm("Save modified buffer<".prevbufname."> first?","&Yes\n&No\n&Cancel") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8369 | " call Decho("(NetrwPrevWinOpen) prevbufname<".prevbufname."> choice=".choice." current-winnr#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8370 | let &ei= eikeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8371 | |
| 8372 | if choice == 1 |
| 8373 | " Yes -- write file & then browse |
| 8374 | let v:errmsg= "" |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 8375 | sil w |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8376 | if v:errmsg != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8377 | call netrw#ErrorMsg(s:ERROR,"unable to write <".(exists("prevbufname")? prevbufname : 'n/a').">!",30) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8378 | exe origwin."wincmd w" |
| 8379 | let &ei = eikeep |
| 8380 | let @@ = ykeep |
| 8381 | " call Dret("s:NetrwPrevWinOpen ".choice." : unable to write <".prevbufname.">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8382 | return choice |
| 8383 | endif |
| 8384 | |
| 8385 | elseif choice == 2 |
| 8386 | " No -- don't worry about changed file, just browse anyway |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8387 | " call Decho("don't worry about chgd file, just browse anyway (winnr($)#".winnr("$").")",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8388 | echomsg "**note** changes to ".prevbufname." abandoned" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8389 | |
| 8390 | else |
| 8391 | " Cancel -- don't do this |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8392 | " call Decho("cancel, don't browse, switch to win#".origwin,'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8393 | exe origwin."wincmd w" |
| 8394 | let &ei= eikeep |
| 8395 | let @@ = ykeep |
| 8396 | " call Dret("s:NetrwPrevWinOpen ".choice." : cancelled") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8397 | return choice |
| 8398 | endif |
| 8399 | endif |
| 8400 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8401 | let &ei= eikeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8402 | endif |
| 8403 | |
| 8404 | " restore b:netrw_curdir (window split/enew may have lost it) |
| 8405 | let b:netrw_curdir= curdir |
| 8406 | if a:islocal < 2 |
| 8407 | if a:islocal |
| 8408 | call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(a:islocal,curword)) |
| 8409 | else |
| 8410 | call s:NetrwBrowse(a:islocal,s:NetrwBrowseChgDir(a:islocal,curword)) |
| 8411 | endif |
| 8412 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8413 | let @@= ykeep |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8414 | " call Dret("s:NetrwPrevWinOpen ".choice) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8415 | return choice |
| 8416 | endfun |
| 8417 | |
| 8418 | " --------------------------------------------------------------------- |
| 8419 | " s:NetrwUpload: load fname to tgt (used by NetrwMarkFileCopy()) {{{2 |
| 8420 | " Always assumed to be local -> remote |
| 8421 | " call s:NetrwUpload(filename, target) |
| 8422 | " call s:NetrwUpload(filename, target, fromdirectory) |
| 8423 | fun! s:NetrwUpload(fname,tgt,...) |
| 8424 | " call Dfunc("s:NetrwUpload(fname<".((type(a:fname) == 1)? a:fname : string(a:fname))."> tgt<".a:tgt.">) a:0=".a:0) |
| 8425 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8426 | if a:tgt =~ '^\a\{3,}://' |
| 8427 | let tgtdir= substitute(a:tgt,'^\a\{3,}://[^/]\+/\(.\{-}\)$','\1','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8428 | else |
| 8429 | let tgtdir= substitute(a:tgt,'^\(.*\)/[^/]*$','\1','') |
| 8430 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8431 | " call Decho("tgtdir<".tgtdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8432 | |
| 8433 | if a:0 > 0 |
| 8434 | let fromdir= a:1 |
| 8435 | else |
| 8436 | let fromdir= getcwd() |
| 8437 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8438 | " call Decho("fromdir<".fromdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8439 | |
| 8440 | if type(a:fname) == 1 |
| 8441 | " handle uploading a single file using NetWrite |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8442 | " call Decho("handle uploading a single file via NetWrite",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8443 | 1split |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8444 | " call Decho("exe e ".fnameescape(s:NetrwFile(a:fname)),'~'.expand("<slnum>")) |
| 8445 | exe "NetrwKeepj e ".fnameescape(s:NetrwFile(a:fname)) |
| 8446 | " call Decho("now locally editing<".expand("%").">, has ".line("$")." lines",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8447 | if a:tgt =~ '/$' |
| 8448 | let wfname= substitute(a:fname,'^.*/','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8449 | " call Decho("exe w! ".fnameescape(wfname),'~'.expand("<slnum>")) |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 8450 | exe "w! ".fnameescape(a:tgt.wfname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8451 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8452 | " call Decho("writing local->remote: exe w ".fnameescape(a:tgt),'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 8453 | exe "w ".fnameescape(a:tgt) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8454 | " call Decho("done writing local->remote",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8455 | endif |
| 8456 | q! |
| 8457 | |
| 8458 | elseif type(a:fname) == 3 |
| 8459 | " handle uploading a list of files via scp |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8460 | " call Decho("handle uploading a list of files via scp",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8461 | let curdir= getcwd() |
| 8462 | if a:tgt =~ '^scp:' |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8463 | if s:NetrwLcd(fromdir) |
| 8464 | " call Dret("s:NetrwUpload : lcd failure") |
| 8465 | return |
| 8466 | endif |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 8467 | let filelist= deepcopy(s:netrwmarkfilelist_{bufnr('%')}) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8468 | let args = join(map(filelist,"s:ShellEscape(v:val, 1)")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8469 | if exists("g:netrw_port") && g:netrw_port != "" |
| 8470 | let useport= " ".g:netrw_scpport." ".g:netrw_port |
| 8471 | else |
| 8472 | let useport= "" |
| 8473 | endif |
| 8474 | let machine = substitute(a:tgt,'^scp://\([^/:]\+\).*$','\1','') |
| 8475 | let tgt = substitute(a:tgt,'^scp://[^/]\+/\(.*\)$','\1','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8476 | call s:NetrwExe(s:netrw_silentxfer."!".g:netrw_scp_cmd.s:ShellEscape(useport,1)." ".args." ".s:ShellEscape(machine.":".tgt,1)) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8477 | if s:NetrwLcd(curdir) |
| 8478 | " call Dret("s:NetrwUpload : lcd failure") |
| 8479 | return |
| 8480 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8481 | |
| 8482 | elseif a:tgt =~ '^ftp:' |
| 8483 | call s:NetrwMethod(a:tgt) |
| 8484 | |
| 8485 | if b:netrw_method == 2 |
| 8486 | " handle uploading a list of files via ftp+.netrc |
| 8487 | let netrw_fname = b:netrw_fname |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8488 | sil NetrwKeepj new |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8489 | " call Decho("filter input window#".winnr(),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8490 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8491 | NetrwKeepj put =g:netrw_ftpmode |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8492 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8493 | |
| 8494 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8495 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8496 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8497 | endif |
| 8498 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8499 | NetrwKeepj call setline(line("$")+1,'lcd "'.fromdir.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8500 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8501 | |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 8502 | if tgtdir == "" |
| 8503 | let tgtdir= '/' |
| 8504 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8505 | NetrwKeepj call setline(line("$")+1,'cd "'.tgtdir.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8506 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8507 | |
| 8508 | for fname in a:fname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8509 | NetrwKeepj call setline(line("$")+1,'put "'.s:NetrwFile(fname).'"') |
| 8510 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8511 | endfor |
| 8512 | |
| 8513 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8514 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8515 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8516 | " call Decho("filter input window#".winnr(),'~'.expand("<slnum>")) |
| 8517 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8518 | endif |
| 8519 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8520 | sil NetrwKeepj g/Local directory now/d |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8521 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8522 | if getline(1) !~ "^$" && !exists("g:netrw_quiet") && getline(1) !~ '^Trying ' |
| 8523 | call netrw#ErrorMsg(s:ERROR,getline(1),14) |
| 8524 | else |
| 8525 | bw!|q |
| 8526 | endif |
| 8527 | |
| 8528 | elseif b:netrw_method == 3 |
| 8529 | " upload with ftp + machine, id, passwd, and fname (ie. no .netrc) |
| 8530 | let netrw_fname= b:netrw_fname |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8531 | NetrwKeepj call s:SaveBufVars()|sil NetrwKeepj new|NetrwKeepj call s:RestoreBufVars() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8532 | let tmpbufnr= bufnr("%") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8533 | setl ff=unix |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8534 | |
| 8535 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8536 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8537 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8538 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8539 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8540 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8541 | endif |
| 8542 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8543 | if exists("g:netrw_uid") && g:netrw_uid != "" |
| 8544 | if exists("g:netrw_ftp") && g:netrw_ftp == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8545 | NetrwKeepj put =g:netrw_uid |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8546 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8547 | if exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8548 | NetrwKeepj call setline(line("$")+1,'"'.s:netrw_passwd.'"') |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8549 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8550 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8551 | elseif exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8552 | NetrwKeepj put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8553 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 8554 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8555 | endif |
| 8556 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8557 | NetrwKeepj call setline(line("$")+1,'lcd "'.fromdir.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8558 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8559 | |
| 8560 | if exists("b:netrw_fname") && b:netrw_fname != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8561 | NetrwKeepj call setline(line("$")+1,'cd "'.b:netrw_fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8562 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8563 | endif |
| 8564 | |
| 8565 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8566 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8567 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8568 | endif |
| 8569 | |
| 8570 | for fname in a:fname |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8571 | NetrwKeepj call setline(line("$")+1,'put "'.fname.'"') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8572 | " call Decho("filter input: ".getline('$'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8573 | endfor |
| 8574 | |
| 8575 | " perform ftp: |
| 8576 | " -i : turns off interactive prompting from ftp |
| 8577 | " -n unix : DON'T use <.netrc>, even though it exists |
| 8578 | " -n win32: quit being obnoxious about password |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8579 | NetrwKeepj norm! 1Gdd |
| 8580 | call s:NetrwExe(s:netrw_silentxfer."%!".s:netrw_ftp_cmd." ".g:netrw_ftp_options) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8581 | " If the result of the ftp operation isn't blank, show an error message (tnx to Doug Claar) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8582 | sil NetrwKeepj g/Local directory now/d |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8583 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8584 | if getline(1) !~ "^$" && !exists("g:netrw_quiet") && getline(1) !~ '^Trying ' |
| 8585 | let debugkeep= &debug |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8586 | setl debug=msg |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8587 | call netrw#ErrorMsg(s:ERROR,getline(1),15) |
| 8588 | let &debug = debugkeep |
| 8589 | let mod = 1 |
| 8590 | else |
| 8591 | bw!|q |
| 8592 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8593 | elseif !exists("b:netrw_method") || b:netrw_method < 0 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8594 | " call Dret("s:#NetrwUpload : unsupported method") |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8595 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8596 | endif |
| 8597 | else |
| 8598 | call netrw#ErrorMsg(s:ERROR,"can't obtain files with protocol from<".a:tgt.">",63) |
| 8599 | endif |
| 8600 | endif |
| 8601 | |
| 8602 | " call Dret("s:NetrwUpload") |
| 8603 | endfun |
| 8604 | |
| 8605 | " --------------------------------------------------------------------- |
| 8606 | " s:NetrwPreview: {{{2 |
| 8607 | fun! s:NetrwPreview(path) range |
| 8608 | " call Dfunc("NetrwPreview(path<".a:path.">)") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8609 | let ykeep= @@ |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8610 | NetrwKeepj call s:NetrwOptionSave("s:") |
| 8611 | NetrwKeepj call s:NetrwSafeOptions() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8612 | if has("quickfix") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8613 | if !isdirectory(s:NetrwFile(a:path)) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 8614 | if g:netrw_preview && !g:netrw_alto |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8615 | let pvhkeep = &pvh |
| 8616 | let winsz = (g:netrw_winsize > 0)? (g:netrw_winsize*winwidth(0))/100 : -g:netrw_winsize |
| 8617 | let &pvh = winwidth(0) - winsz |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 8618 | endif |
| 8619 | exe (g:netrw_alto? "top " : "bot ").(g:netrw_preview? "vert " : "")."pedit ".fnameescape(a:path) |
| 8620 | if exists("pvhkeep") |
| 8621 | let &pvh= pvhkeep |
| 8622 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8623 | elseif !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8624 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"sorry, cannot preview a directory such as <".a:path.">",38) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8625 | endif |
| 8626 | elseif !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8627 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"sorry, to preview your vim needs the quickfix feature compiled in",39) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8628 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8629 | NetrwKeepj call s:NetrwOptionRestore("s:") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8630 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8631 | " call Dret("NetrwPreview") |
| 8632 | endfun |
| 8633 | |
| 8634 | " --------------------------------------------------------------------- |
| 8635 | " s:NetrwRefresh: {{{2 |
| 8636 | fun! s:NetrwRefresh(islocal,dirname) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8637 | " call Dfunc("s:NetrwRefresh(islocal<".a:islocal.">,dirname=".a:dirname.") hide=".g:netrw_hide." sortdir=".g:netrw_sort_direction) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8638 | " at the current time (Mar 19, 2007) all calls to NetrwRefresh() call NetrwBrowseChgDir() first. |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8639 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8640 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
| 8641 | " call Decho("clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8642 | let ykeep = @@ |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8643 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
| 8644 | if !exists("w:netrw_treetop") |
| 8645 | if exists("b:netrw_curdir") |
| 8646 | let w:netrw_treetop= b:netrw_curdir |
| 8647 | else |
| 8648 | let w:netrw_treetop= getcwd() |
| 8649 | endif |
| 8650 | endif |
| 8651 | NetrwKeepj call s:NetrwRefreshTreeDict(w:netrw_treetop) |
| 8652 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8653 | |
| 8654 | " save the cursor position before refresh. |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8655 | let screenposn = winsaveview() |
| 8656 | " call Decho("saving posn to screenposn<".string(screenposn).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8657 | |
| 8658 | " call Decho("win#".winnr().": ".winheight(0)."x".winwidth(0)." curfile<".expand("%").">",'~'.expand("<slnum>")) |
| 8659 | " call Decho("clearing buffer prior to refresh",'~'.expand("<slnum>")) |
| 8660 | sil! NetrwKeepj %d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8661 | if a:islocal |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8662 | NetrwKeepj call netrw#LocalBrowseCheck(a:dirname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8663 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8664 | NetrwKeepj call s:NetrwBrowse(a:islocal,a:dirname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8665 | endif |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8666 | |
| 8667 | " restore position |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8668 | " call Decho("restoring posn to screenposn<".string(screenposn).">",'~'.expand("<slnum>")) |
| 8669 | NetrwKeepj call winrestview(screenposn) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8670 | |
| 8671 | " restore file marks |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 8672 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 8673 | if exists("s:netrwmarkfilemtch_{bufnr('%')}") && s:netrwmarkfilemtch_{bufnr("%")} != "" |
| 8674 | " " call Decho("exe 2match netrwMarkFile /".s:netrwmarkfilemtch_{bufnr("%")}."/",'~'.expand("<slnum>")) |
| 8675 | exe "2match netrwMarkFile /".s:netrwmarkfilemtch_{bufnr("%")}."/" |
| 8676 | else |
| 8677 | " " call Decho("2match none (bufnr(%)=".bufnr("%")."<".bufname("%").">)",'~'.expand("<slnum>")) |
| 8678 | 2match none |
| 8679 | endif |
| 8680 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8681 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8682 | " restore |
| 8683 | let @@= ykeep |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8684 | " call Dret("s:NetrwRefresh") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8685 | endfun |
| 8686 | |
| 8687 | " --------------------------------------------------------------------- |
| 8688 | " s:NetrwRefreshDir: refreshes a directory by name {{{2 |
| 8689 | " Called by NetrwMarkFileCopy() |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8690 | " Interfaces to s:NetrwRefresh() and s:LocalBrowseRefresh() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8691 | fun! s:NetrwRefreshDir(islocal,dirname) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8692 | " call Dfunc("s:NetrwRefreshDir(islocal=".a:islocal." dirname<".a:dirname.">) g:netrw_fastbrowse=".g:netrw_fastbrowse) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8693 | if g:netrw_fastbrowse == 0 |
| 8694 | " slowest mode (keep buffers refreshed, local or remote) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8695 | " call Decho("slowest mode: keep buffers refreshed, local or remote",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8696 | let tgtwin= bufwinnr(a:dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8697 | " call Decho("tgtwin= bufwinnr(".a:dirname.")=".tgtwin,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8698 | |
| 8699 | if tgtwin > 0 |
| 8700 | " tgtwin is being displayed, so refresh it |
| 8701 | let curwin= winnr() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8702 | " call Decho("refresh tgtwin#".tgtwin." (curwin#".curwin.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8703 | exe tgtwin."wincmd w" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8704 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8705 | exe curwin."wincmd w" |
| 8706 | |
| 8707 | elseif bufnr(a:dirname) > 0 |
| 8708 | let bn= bufnr(a:dirname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8709 | " call Decho("bd bufnr(".a:dirname.")=".bn,'~'.expand("<slnum>")) |
| 8710 | exe "sil keepj bd ".bn |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8711 | endif |
| 8712 | |
| 8713 | elseif g:netrw_fastbrowse <= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8714 | " call Decho("medium-speed mode: refresh local buffers only",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8715 | NetrwKeepj call s:LocalBrowseRefresh() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8716 | endif |
| 8717 | " call Dret("s:NetrwRefreshDir") |
| 8718 | endfun |
| 8719 | |
| 8720 | " --------------------------------------------------------------------- |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8721 | " s:NetrwSetChgwin: set g:netrw_chgwin; a <cr> will use the specified |
| 8722 | " window number to do its editing in. |
| 8723 | " Supports [count]C where the count, if present, is used to specify |
| 8724 | " a window to use for editing via the <cr> mapping. |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8725 | fun! s:NetrwSetChgwin(...) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8726 | " call Dfunc("s:NetrwSetChgwin() v:count=".v:count) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8727 | if a:0 > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8728 | " call Decho("a:1<".a:1.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8729 | if a:1 == "" " :NetrwC win# |
| 8730 | let g:netrw_chgwin= winnr() |
| 8731 | else " :NetrwC |
| 8732 | let g:netrw_chgwin= a:1 |
| 8733 | endif |
| 8734 | elseif v:count > 0 " [count]C |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8735 | let g:netrw_chgwin= v:count |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8736 | else " C |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8737 | let g:netrw_chgwin= winnr() |
| 8738 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8739 | echo "editing window now set to window#".g:netrw_chgwin |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8740 | " call Dret("s:NetrwSetChgwin : g:netrw_chgwin=".g:netrw_chgwin) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8741 | endfun |
| 8742 | |
| 8743 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8744 | " s:NetrwSetSort: sets up the sort based on the g:netrw_sort_sequence {{{2 |
| 8745 | " What this function does is to compute a priority for the patterns |
| 8746 | " in the g:netrw_sort_sequence. It applies a substitute to any |
| 8747 | " "files" that satisfy each pattern, putting the priority / in |
| 8748 | " front. An "*" pattern handles the default priority. |
| 8749 | fun! s:NetrwSetSort() |
| 8750 | " call Dfunc("SetSort() bannercnt=".w:netrw_bannercnt) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8751 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8752 | if w:netrw_liststyle == s:LONGLIST |
| 8753 | let seqlist = substitute(g:netrw_sort_sequence,'\$','\\%(\t\\|\$\\)','ge') |
| 8754 | else |
| 8755 | let seqlist = g:netrw_sort_sequence |
| 8756 | endif |
| 8757 | " sanity check -- insure that * appears somewhere |
| 8758 | if seqlist == "" |
| 8759 | let seqlist= '*' |
| 8760 | elseif seqlist !~ '\*' |
| 8761 | let seqlist= seqlist.',*' |
| 8762 | endif |
| 8763 | let priority = 1 |
| 8764 | while seqlist != "" |
| 8765 | if seqlist =~ ',' |
| 8766 | let seq = substitute(seqlist,',.*$','','e') |
| 8767 | let seqlist = substitute(seqlist,'^.\{-},\(.*\)$','\1','e') |
| 8768 | else |
| 8769 | let seq = seqlist |
| 8770 | let seqlist = "" |
| 8771 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8772 | if priority < 10 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8773 | let spriority= "00".priority.g:netrw_sepchr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8774 | elseif priority < 100 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8775 | let spriority= "0".priority.g:netrw_sepchr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8776 | else |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8777 | let spriority= priority.g:netrw_sepchr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8778 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8779 | " call Decho("priority=".priority." spriority<".spriority."> seq<".seq."> seqlist<".seqlist.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8780 | |
| 8781 | " sanity check |
| 8782 | if w:netrw_bannercnt > line("$") |
| 8783 | " apparently no files were left after a Hiding pattern was used |
| 8784 | " call Dret("SetSort : no files left after hiding") |
| 8785 | return |
| 8786 | endif |
| 8787 | if seq == '*' |
| 8788 | let starpriority= spriority |
| 8789 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8790 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$g/'.seq.'/s/^/'.spriority.'/' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8791 | call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8792 | " sometimes multiple sorting patterns will match the same file or directory. |
| 8793 | " The following substitute is intended to remove the excess matches. |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8794 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$g/^\d\{3}'.g:netrw_sepchr.'\d\{3}\//s/^\d\{3}'.g:netrw_sepchr.'\(\d\{3}\/\).\@=/\1/e' |
| 8795 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8796 | endif |
| 8797 | let priority = priority + 1 |
| 8798 | endwhile |
| 8799 | if exists("starpriority") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8800 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$v/^\d\{3}'.g:netrw_sepchr.'/s/^/'.starpriority.'/e' |
| 8801 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8802 | endif |
| 8803 | |
| 8804 | " Following line associated with priority -- items that satisfy a priority |
| 8805 | " pattern get prefixed by ###/ which permits easy sorting by priority. |
| 8806 | " Sometimes files can satisfy multiple priority patterns -- only the latest |
| 8807 | " priority pattern needs to be retained. So, at this point, these excess |
| 8808 | " priority prefixes need to be removed, but not directories that happen to |
| 8809 | " be just digits themselves. |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8810 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$s/^\(\d\{3}'.g:netrw_sepchr.'\)\%(\d\{3}'.g:netrw_sepchr.'\)\+\ze./\1/e' |
| 8811 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8812 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8813 | |
| 8814 | " call Dret("SetSort") |
| 8815 | endfun |
| 8816 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8817 | " --------------------------------------------------------------------- |
| 8818 | " s:NetrwSetTgt: sets the target to the specified choice index {{{2 |
| 8819 | " Implements [count]Tb (bookhist<b>) |
| 8820 | " [count]Th (bookhist<h>) |
| 8821 | " See :help netrw-qb for how to make the choice. |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8822 | fun! s:NetrwSetTgt(islocal,bookhist,choice) |
| 8823 | " call Dfunc("s:NetrwSetTgt(islocal=".a:islocal." bookhist<".a:bookhist."> choice#".a:choice.")") |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8824 | |
| 8825 | if a:bookhist == 'b' |
| 8826 | " supports choosing a bookmark as a target using a qb-generated list |
| 8827 | let choice= a:choice - 1 |
| 8828 | if exists("g:netrw_bookmarklist[".choice."]") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8829 | call netrw#MakeTgt(g:netrw_bookmarklist[choice]) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8830 | else |
| 8831 | echomsg "Sorry, bookmark#".a:choice." doesn't exist!" |
| 8832 | endif |
| 8833 | |
| 8834 | elseif a:bookhist == 'h' |
| 8835 | " supports choosing a history stack entry as a target using a qb-generated list |
| 8836 | let choice= (a:choice % g:netrw_dirhistmax) + 1 |
| 8837 | if exists("g:netrw_dirhist_".choice) |
| 8838 | let histentry = g:netrw_dirhist_{choice} |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8839 | call netrw#MakeTgt(histentry) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8840 | else |
| 8841 | echomsg "Sorry, history#".a:choice." not available!" |
| 8842 | endif |
| 8843 | endif |
| 8844 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8845 | " refresh the display |
| 8846 | if !exists("b:netrw_curdir") |
| 8847 | let b:netrw_curdir= getcwd() |
| 8848 | endif |
| 8849 | call s:NetrwRefresh(a:islocal,b:netrw_curdir) |
| 8850 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8851 | " call Dret("s:NetrwSetTgt") |
| 8852 | endfun |
| 8853 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8854 | " ===================================================================== |
| 8855 | " s:NetrwSortStyle: change sorting style (name - time - size) and refresh display {{{2 |
| 8856 | fun! s:NetrwSortStyle(islocal) |
| 8857 | " call Dfunc("s:NetrwSortStyle(islocal=".a:islocal.") netrw_sort_by<".g:netrw_sort_by.">") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8858 | NetrwKeepj call s:NetrwSaveWordPosn() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8859 | let svpos= winsaveview() |
| 8860 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8861 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 8862 | let g:netrw_sort_by= (g:netrw_sort_by =~# '^n')? 'time' : (g:netrw_sort_by =~# '^t')? 'size' : (g:netrw_sort_by =~# '^siz')? 'exten' : 'name' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8863 | NetrwKeepj norm! 0 |
| 8864 | NetrwKeepj call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 8865 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 8866 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8867 | |
| 8868 | " call Dret("s:NetrwSortStyle : netrw_sort_by<".g:netrw_sort_by.">") |
| 8869 | endfun |
| 8870 | |
| 8871 | " --------------------------------------------------------------------- |
| 8872 | " s:NetrwSplit: mode {{{2 |
| 8873 | " =0 : net and o |
| 8874 | " =1 : net and t |
| 8875 | " =2 : net and v |
| 8876 | " =3 : local and o |
| 8877 | " =4 : local and t |
| 8878 | " =5 : local and v |
| 8879 | fun! s:NetrwSplit(mode) |
| 8880 | " call Dfunc("s:NetrwSplit(mode=".a:mode.") alto=".g:netrw_alto." altv=".g:netrw_altv) |
| 8881 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8882 | let ykeep= @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8883 | call s:SaveWinVars() |
| 8884 | |
| 8885 | if a:mode == 0 |
| 8886 | " remote and o |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8887 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winheight(0))/100 : -g:netrw_winsize |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8888 | if winsz == 0|let winsz= ""|endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8889 | " call Decho("exe ".(g:netrw_alto? "bel " : "abo ").winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 8890 | exe (g:netrw_alto? "bel " : "abo ").winsz."wincmd s" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8891 | let s:didsplit= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8892 | NetrwKeepj call s:RestoreWinVars() |
| 8893 | NetrwKeepj call s:NetrwBrowse(0,s:NetrwBrowseChgDir(0,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8894 | unlet s:didsplit |
| 8895 | |
| 8896 | elseif a:mode == 1 |
| 8897 | " remote and t |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 8898 | let newdir = s:NetrwBrowseChgDir(0,s:NetrwGetWord()) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8899 | " call Decho("tabnew",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8900 | tabnew |
| 8901 | let s:didsplit= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8902 | NetrwKeepj call s:RestoreWinVars() |
| 8903 | NetrwKeepj call s:NetrwBrowse(0,newdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8904 | unlet s:didsplit |
| 8905 | |
| 8906 | elseif a:mode == 2 |
| 8907 | " remote and v |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8908 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winwidth(0))/100 : -g:netrw_winsize |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8909 | if winsz == 0|let winsz= ""|endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8910 | " call Decho("exe ".(g:netrw_altv? "rightb " : "lefta ").winsz."wincmd v",'~'.expand("<slnum>")) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 8911 | exe (g:netrw_altv? "rightb " : "lefta ").winsz."wincmd v" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8912 | let s:didsplit= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8913 | NetrwKeepj call s:RestoreWinVars() |
| 8914 | NetrwKeepj call s:NetrwBrowse(0,s:NetrwBrowseChgDir(0,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8915 | unlet s:didsplit |
| 8916 | |
| 8917 | elseif a:mode == 3 |
| 8918 | " local and o |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8919 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winheight(0))/100 : -g:netrw_winsize |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8920 | if winsz == 0|let winsz= ""|endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8921 | " call Decho("exe ".(g:netrw_alto? "bel " : "abo ").winsz."wincmd s",'~'.expand("<slnum>")) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 8922 | exe (g:netrw_alto? "bel " : "abo ").winsz."wincmd s" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8923 | let s:didsplit= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8924 | NetrwKeepj call s:RestoreWinVars() |
| 8925 | NetrwKeepj call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8926 | unlet s:didsplit |
| 8927 | |
| 8928 | elseif a:mode == 4 |
| 8929 | " local and t |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8930 | let cursorword = s:NetrwGetWord() |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8931 | let eikeep = &ei |
| 8932 | let netrw_winnr = winnr() |
| 8933 | let netrw_line = line(".") |
| 8934 | let netrw_col = virtcol(".") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8935 | NetrwKeepj norm! H0 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8936 | let netrw_hline = line(".") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8937 | setl ei=all |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8938 | exe "NetrwKeepj norm! ".netrw_hline."G0z\<CR>" |
| 8939 | exe "NetrwKeepj norm! ".netrw_line."G0".netrw_col."\<bar>" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8940 | let &ei = eikeep |
| 8941 | let netrw_curdir = s:NetrwTreeDir(0) |
| 8942 | " call Decho("tabnew",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8943 | tabnew |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8944 | let b:netrw_curdir = netrw_curdir |
| 8945 | let s:didsplit = 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8946 | NetrwKeepj call s:RestoreWinVars() |
| 8947 | NetrwKeepj call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,cursorword)) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8948 | if &ft == "netrw" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 8949 | setl ei=all |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8950 | exe "NetrwKeepj norm! ".netrw_hline."G0z\<CR>" |
| 8951 | exe "NetrwKeepj norm! ".netrw_line."G0".netrw_col."\<bar>" |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 8952 | let &ei= eikeep |
| 8953 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8954 | unlet s:didsplit |
| 8955 | |
| 8956 | elseif a:mode == 5 |
| 8957 | " local and v |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 8958 | let winsz= (g:netrw_winsize > 0)? (g:netrw_winsize*winwidth(0))/100 : -g:netrw_winsize |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 8959 | if winsz == 0|let winsz= ""|endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8960 | " call Decho("exe ".(g:netrw_altv? "rightb " : "lefta ").winsz."wincmd v",'~'.expand("<slnum>")) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 8961 | exe (g:netrw_altv? "rightb " : "lefta ").winsz."wincmd v" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8962 | let s:didsplit= 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8963 | NetrwKeepj call s:RestoreWinVars() |
| 8964 | NetrwKeepj call netrw#LocalBrowseCheck(s:NetrwBrowseChgDir(1,s:NetrwGetWord())) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8965 | unlet s:didsplit |
| 8966 | |
| 8967 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 8968 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"(NetrwSplit) unsupported mode=".a:mode,45) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8969 | endif |
| 8970 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 8971 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8972 | " call Dret("s:NetrwSplit") |
| 8973 | endfun |
| 8974 | |
| 8975 | " --------------------------------------------------------------------- |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8976 | " s:NetrwTgtMenu: {{{2 |
| 8977 | fun! s:NetrwTgtMenu() |
| 8978 | if !exists("s:netrw_menucnt") |
| 8979 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 8980 | endif |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8981 | " call Dfunc("s:NetrwTgtMenu()") |
| 8982 | |
| 8983 | " the following test assures that gvim is running, has menus available, and has menus enabled. |
| 8984 | if has("gui") && has("menu") && has("gui_running") && &go =~# 'm' && g:netrw_menu |
| 8985 | if exists("g:NetrwTopLvlMenu") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8986 | " call Decho("removing ".g:NetrwTopLvlMenu."Bookmarks menu item(s)",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8987 | exe 'sil! unmenu '.g:NetrwTopLvlMenu.'Targets' |
| 8988 | endif |
| 8989 | if !exists("s:netrw_initbookhist") |
| 8990 | call s:NetrwBookHistRead() |
| 8991 | endif |
| 8992 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8993 | " try to cull duplicate entries |
| 8994 | let tgtdict={} |
| 8995 | |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8996 | " target bookmarked places |
| 8997 | if exists("g:netrw_bookmarklist") && g:netrw_bookmarklist != [] && g:netrw_dirhistmax > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 8998 | " call Decho("installing bookmarks as easy targets",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 8999 | let cnt= 1 |
| 9000 | for bmd in g:netrw_bookmarklist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9001 | if has_key(tgtdict,bmd) |
| 9002 | let cnt= cnt + 1 |
| 9003 | continue |
| 9004 | endif |
| 9005 | let tgtdict[bmd]= cnt |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9006 | let ebmd= escape(bmd,g:netrw_menu_escape) |
| 9007 | " show bookmarks for goto menu |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9008 | " call Decho("menu: Targets: ".bmd,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9009 | exe 'sil! menu <silent> '.g:NetrwMenuPriority.".19.1.".cnt." ".g:NetrwTopLvlMenu.'Targets.'.ebmd." :call netrw#MakeTgt('".bmd."')\<cr>" |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9010 | let cnt= cnt + 1 |
| 9011 | endfor |
| 9012 | endif |
| 9013 | |
| 9014 | " target directory browsing history |
| 9015 | if exists("g:netrw_dirhistmax") && g:netrw_dirhistmax > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9016 | " call Decho("installing history as easy targets (histmax=".g:netrw_dirhistmax.")",'~'.expand("<slnum>")) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9017 | let histcnt = 1 |
| 9018 | while histcnt <= g:netrw_dirhistmax |
| 9019 | let priority = g:netrw_dirhist_cnt + histcnt |
| 9020 | if exists("g:netrw_dirhist_{histcnt}") |
| 9021 | let histentry = g:netrw_dirhist_{histcnt} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9022 | if has_key(tgtdict,histentry) |
| 9023 | let histcnt = histcnt + 1 |
| 9024 | continue |
| 9025 | endif |
| 9026 | let tgtdict[histentry] = histcnt |
| 9027 | let ehistentry = escape(histentry,g:netrw_menu_escape) |
| 9028 | " call Decho("menu: Targets: ".histentry,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9029 | exe 'sil! menu <silent> '.g:NetrwMenuPriority.".19.2.".priority." ".g:NetrwTopLvlMenu.'Targets.'.ehistentry." :call netrw#MakeTgt('".histentry."')\<cr>" |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9030 | endif |
| 9031 | let histcnt = histcnt + 1 |
| 9032 | endwhile |
| 9033 | endif |
| 9034 | endif |
| 9035 | " call Dret("s:NetrwTgtMenu") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9036 | endfun |
| 9037 | |
| 9038 | " --------------------------------------------------------------------- |
| 9039 | " s:NetrwTreeDir: determine tree directory given current cursor position {{{2 |
| 9040 | " (full path directory with trailing slash returned) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9041 | fun! s:NetrwTreeDir(islocal) |
| 9042 | " call Dfunc("s:NetrwTreeDir(islocal=".a:islocal.") getline(".line(".").")"."<".getline('.')."> b:netrw_curdir<".b:netrw_curdir."> tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> ft=".&ft) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9043 | " call Decho("g:netrw_keepdir =".(exists("g:netrw_keepdir")? g:netrw_keepdir : 'n/a'),'~'.expand("<slnum>")) |
| 9044 | " call Decho("w:netrw_liststyle=".(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'),'~'.expand("<slnum>")) |
| 9045 | " call Decho("w:netrw_treetop =".(exists("w:netrw_treetop")? w:netrw_treetop : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9046 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9047 | if exists("s:treedir") |
| 9048 | " s:NetrwPrevWinOpen opens a "previous" window -- and thus needs to and does call s:NetrwTreeDir early |
| 9049 | let treedir= s:treedir |
| 9050 | unlet s:treedir |
| 9051 | " call Dret("s:NetrwTreeDir ".treedir) |
| 9052 | return treedir |
| 9053 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9054 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9055 | if !exists("b:netrw_curdir") || b:netrw_curdir == "" |
| 9056 | let b:netrw_curdir= getcwd() |
| 9057 | endif |
| 9058 | let treedir = b:netrw_curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9059 | " call Decho("set initial treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9060 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9061 | let s:treecurpos= winsaveview() |
| 9062 | " call Decho("saving posn to s:treecurpos<".string(s:treecurpos).">",'~'.expand("<slnum>")) |
| 9063 | |
| 9064 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9065 | " call Decho("w:netrw_liststyle is TREELIST:",'~'.expand("<slnum>")) |
| 9066 | " call Decho("line#".line(".")." getline(.)<".getline('.')."> treecurpos<".string(s:treecurpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9067 | |
| 9068 | " extract tree directory if on a line specifying a subdirectory (ie. ends with "/") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9069 | let curline= substitute(getline('.'),"\t -->.*$",'','') |
| 9070 | if curline =~ '/$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9071 | " call Decho("extract tree subdirectory from current line",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9072 | let treedir= substitute(getline('.'),'^\%('.s:treedepthstring.'\)*\([^'.s:treedepthstring.'].\{-}\)$','\1','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9073 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
| 9074 | elseif curline =~ '@$' |
| 9075 | " call Decho("handle symbolic link from current line",'~'.expand("<slnum>")) |
| 9076 | let treedir= resolve(substitute(substitute(getline('.'),'@.*$','','e'),'^|*\s*','','e')) |
| 9077 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9078 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9079 | " call Decho("do not extract tree subdirectory from current line and set treedir to empty",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9080 | let treedir= "" |
| 9081 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9082 | |
| 9083 | " detect user attempting to close treeroot |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9084 | " call Decho("check if user is attempting to close treeroot",'~'.expand("<slnum>")) |
| 9085 | " call Decho(".win#".winnr()." buf#".bufnr("%")."<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9086 | " call Decho(".getline(".line(".").")<".getline('.').'> '.((getline('.') =~# '^'.s:treedepthstring)? '=~#' : '!~').' ^'.s:treedepthstring,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9087 | if curline !~ '^'.s:treedepthstring && getline('.') != '..' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9088 | " call Decho(".user may have attempted to close treeroot",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9089 | " now force a refresh |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9090 | " call Decho(".force refresh: clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
| 9091 | sil! NetrwKeepj %d _ |
| 9092 | " call Dret("s:NetrwTreeDir <".treedir."> : (side effect) s:treecurpos<".(exists("s:treecurpos")? string(s:treecurpos) : 'n/a').">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9093 | return b:netrw_curdir |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9094 | " else " Decho |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9095 | " call Decho(".user not attempting to close treeroot",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9096 | endif |
| 9097 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9098 | " call Decho("islocal=".a:islocal." curline<".curline.">",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9099 | let potentialdir= s:NetrwFile(substitute(curline,'^'.s:treedepthstring.'\+ \(.*\)@$','\1','')) |
| 9100 | " call Decho("potentialdir<".potentialdir."> isdir=".isdirectory(potentialdir),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9101 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9102 | " COMBAK: a symbolic link may point anywhere -- so it will be used to start a new treetop |
| 9103 | " if a:islocal && curline =~ '@$' && isdirectory(s:NetrwFile(potentialdir)) |
| 9104 | " let newdir = w:netrw_treetop.'/'.potentialdir |
| 9105 | " " call Decho("apply NetrwTreePath to newdir<".newdir.">",'~'.expand("<slnum>")) |
| 9106 | " let treedir = s:NetrwTreePath(newdir) |
| 9107 | " let w:netrw_treetop = newdir |
| 9108 | " " call Decho("newdir <".newdir.">",'~'.expand("<slnum>")) |
| 9109 | " else |
| 9110 | " call Decho("apply NetrwTreePath to treetop<".w:netrw_treetop.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9111 | let treedir = s:NetrwTreePath(w:netrw_treetop) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9112 | " endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9113 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9114 | |
| 9115 | " sanity maintenance: keep those //s away... |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9116 | let treedir= substitute(treedir,'//$','/','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9117 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9118 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9119 | " call Dret("s:NetrwTreeDir <".treedir."> : (side effect) s:treecurpos<".(exists("s:treecurpos")? string(s:treecurpos) : 'n/a').">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9120 | return treedir |
| 9121 | endfun |
| 9122 | |
| 9123 | " --------------------------------------------------------------------- |
| 9124 | " s:NetrwTreeDisplay: recursive tree display {{{2 |
| 9125 | fun! s:NetrwTreeDisplay(dir,depth) |
| 9126 | " call Dfunc("NetrwTreeDisplay(dir<".a:dir."> depth<".a:depth.">)") |
| 9127 | |
| 9128 | " insure that there are no folds |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9129 | setl nofen |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9130 | |
| 9131 | " install ../ and shortdir |
| 9132 | if a:depth == "" |
| 9133 | call setline(line("$")+1,'../') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9134 | " call Decho("setline#".line("$")." ../ (depth is zero)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9135 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9136 | if a:dir =~ '^\a\{3,}://' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9137 | if a:dir == w:netrw_treetop |
| 9138 | let shortdir= a:dir |
| 9139 | else |
| 9140 | let shortdir= substitute(a:dir,'^.*/\([^/]\+\)/$','\1/','e') |
| 9141 | endif |
| 9142 | call setline(line("$")+1,a:depth.shortdir) |
| 9143 | else |
| 9144 | let shortdir= substitute(a:dir,'^.*/','','e') |
| 9145 | call setline(line("$")+1,a:depth.shortdir.'/') |
| 9146 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9147 | " call Decho("setline#".line("$")." shortdir<".a:depth.shortdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9148 | |
| 9149 | " append a / to dir if its missing one |
| 9150 | let dir= a:dir |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9151 | |
| 9152 | " display subtrees (if any) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9153 | let depth= s:treedepthstring.a:depth |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9154 | " call Decho("display subtrees with depth<".depth."> and current leaves",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9155 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9156 | " implement g:netrw_hide for tree listings (uses g:netrw_list_hide) |
| 9157 | if g:netrw_hide == 1 |
| 9158 | " hide given patterns |
| 9159 | let listhide= split(g:netrw_list_hide,',') |
| 9160 | " call Decho("listhide=".string(listhide)) |
| 9161 | for pat in listhide |
| 9162 | call filter(w:netrw_treedict[dir],'v:val !~ "'.pat.'"') |
| 9163 | endfor |
| 9164 | |
| 9165 | elseif g:netrw_hide == 2 |
| 9166 | " show given patterns (only) |
| 9167 | let listhide= split(g:netrw_list_hide,',') |
| 9168 | " call Decho("listhide=".string(listhide)) |
| 9169 | let entries=[] |
| 9170 | for entry in w:netrw_treedict[dir] |
| 9171 | for pat in listhide |
| 9172 | if entry =~ pat |
| 9173 | call add(entries,entry) |
| 9174 | break |
| 9175 | endif |
| 9176 | endfor |
| 9177 | endfor |
| 9178 | let w:netrw_treedict[dir]= entries |
| 9179 | endif |
| 9180 | if depth != "" |
| 9181 | " always remove "." and ".." entries when there's depth |
| 9182 | call filter(w:netrw_treedict[dir],'v:val !~ "\\.\\.$"') |
| 9183 | call filter(w:netrw_treedict[dir],'v:val !~ "\\.$"') |
| 9184 | endif |
| 9185 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9186 | " call Decho("for every entry in w:netrw_treedict[".dir."]=".string(w:netrw_treedict[dir]),'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9187 | for entry in w:netrw_treedict[dir] |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9188 | if dir =~ '/$' |
| 9189 | let direntry= substitute(dir.entry,'[@/]$','','e') |
| 9190 | else |
| 9191 | let direntry= substitute(dir.'/'.entry,'[@/]$','','e') |
| 9192 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9193 | " call Decho("dir<".dir."> entry<".entry."> direntry<".direntry.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9194 | if entry =~ '/$' && has_key(w:netrw_treedict,direntry) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9195 | " call Decho("<".direntry."> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9196 | NetrwKeepj call s:NetrwTreeDisplay(direntry,depth) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9197 | elseif entry =~ '/$' && has_key(w:netrw_treedict,direntry.'/') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9198 | " call Decho("<".direntry."/> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
| 9199 | NetrwKeepj call s:NetrwTreeDisplay(direntry.'/',depth) |
| 9200 | elseif entry =~ '@$' && has_key(w:netrw_treedict,direntry.'@') |
| 9201 | " call Decho("<".direntry."/> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9202 | NetrwKeepj call s:NetrwTreeDisplay(direntry.'/',depth) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9203 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9204 | " call Decho("<".entry."> is not a key in treedict (no subtree)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9205 | sil! NetrwKeepj call setline(line("$")+1,depth.entry) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9206 | endif |
| 9207 | endfor |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9208 | " call Decho("displaying: ".string(getline(w:netrw_bannercnt,'$'))) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9209 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9210 | " call Dret("NetrwTreeDisplay") |
| 9211 | endfun |
| 9212 | |
| 9213 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9214 | " s:NetrwRefreshTreeDict: updates the contents information for a tree (w:netrw_treedict) {{{2 |
| 9215 | fun! s:NetrwRefreshTreeDict(dir) |
| 9216 | " call Dfunc("s:NetrwRefreshTreeDict(dir<".a:dir.">)") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9217 | if !exists("w:netrw_treedict") |
| 9218 | " call Dret("s:NetrwRefreshTreeDict : w:netrw_treedict doesn't exist") |
| 9219 | return |
| 9220 | endif |
| 9221 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9222 | for entry in w:netrw_treedict[a:dir] |
| 9223 | let direntry= substitute(a:dir.'/'.entry,'[@/]$','','e') |
| 9224 | " call Decho("a:dir<".a:dir."> entry<".entry."> direntry<".direntry.">",'~'.expand("<slnum>")) |
| 9225 | |
| 9226 | if entry =~ '/$' && has_key(w:netrw_treedict,direntry) |
| 9227 | " call Decho("<".direntry."> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
| 9228 | NetrwKeepj call s:NetrwRefreshTreeDict(direntry) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9229 | let liststar = s:NetrwGlob(direntry,'*',1) |
| 9230 | let listdotstar = s:NetrwGlob(direntry,'.*',1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9231 | let w:netrw_treedict[direntry] = liststar + listdotstar |
| 9232 | " call Decho("updating w:netrw_treedict[".direntry.']='.string(w:netrw_treedict[direntry]),'~'.expand("<slnum>")) |
| 9233 | |
| 9234 | elseif entry =~ '/$' && has_key(w:netrw_treedict,direntry.'/') |
| 9235 | " call Decho("<".direntry."/> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
| 9236 | NetrwKeepj call s:NetrwRefreshTreeDict(direntry.'/') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9237 | let liststar = s:NetrwGlob(direntry.'/','*',1) |
| 9238 | let listdotstar= s:NetrwGlob(direntry.'/','.*',1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9239 | let w:netrw_treedict[direntry]= liststar + listdotstar |
| 9240 | " call Decho("updating w:netrw_treedict[".direntry.']='.string(w:netrw_treedict[direntry]),'~'.expand("<slnum>")) |
| 9241 | |
| 9242 | elseif entry =~ '@$' && has_key(w:netrw_treedict,direntry.'@') |
| 9243 | " call Decho("<".direntry."/> is a key in treedict - display subtree for it",'~'.expand("<slnum>")) |
| 9244 | NetrwKeepj call s:NetrwRefreshTreeDict(direntry.'/') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9245 | let liststar = s:NetrwGlob(direntry.'/','*',1) |
| 9246 | let listdotstar= s:NetrwGlob(direntry.'/','.*',1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9247 | " call Decho("updating w:netrw_treedict[".direntry.']='.string(w:netrw_treedict[direntry]),'~'.expand("<slnum>")) |
| 9248 | |
| 9249 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9250 | " call Decho('not updating w:netrw_treedict['.string(direntry).'] with entry<'.string(entry).'> (no subtree)','~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9251 | endif |
| 9252 | endfor |
| 9253 | " call Dret("s:NetrwRefreshTreeDict") |
| 9254 | endfun |
| 9255 | |
| 9256 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9257 | " s:NetrwTreeListing: displays tree listing from treetop on down, using NetrwTreeDisplay() {{{2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9258 | " Called by s:PerformListing() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9259 | fun! s:NetrwTreeListing(dirname) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9260 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9261 | " call Dfunc("NetrwTreeListing() bufname<".expand("%").">") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9262 | " call Decho("curdir<".a:dirname.">",'~'.expand("<slnum>")) |
| 9263 | " call Decho("win#".winnr().": w:netrw_treetop ".(exists("w:netrw_treetop")? "exists" : "doesn't exist")." w:netrw_treedict ".(exists("w:netrw_treedict")? "exists" : "doesn't exit"),'~'.expand("<slnum>")) |
| 9264 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9265 | |
| 9266 | " update the treetop |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9267 | " call Decho("update the treetop",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9268 | if !exists("w:netrw_treetop") |
| 9269 | let w:netrw_treetop= a:dirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9270 | " call Decho("w:netrw_treetop<".w:netrw_treetop."> (reusing)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9271 | elseif (w:netrw_treetop =~ ('^'.a:dirname) && s:Strlen(a:dirname) < s:Strlen(w:netrw_treetop)) || a:dirname !~ ('^'.w:netrw_treetop) |
| 9272 | let w:netrw_treetop= a:dirname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9273 | " call Decho("w:netrw_treetop<".w:netrw_treetop."> (went up)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9274 | endif |
| 9275 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9276 | if !exists("w:netrw_treedict") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9277 | " insure that we have a treedict, albeit empty |
| 9278 | " call Decho("initializing w:netrw_treedict to empty",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9279 | let w:netrw_treedict= {} |
| 9280 | endif |
| 9281 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9282 | " update the dictionary for the current directory |
| 9283 | " call Decho("updating: w:netrw_treedict[".a:dirname.'] -> [directory listing]','~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9284 | " call Decho("w:netrw_bannercnt=".w:netrw_bannercnt." line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9285 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.',$g@^\.\.\=/$@d _' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9286 | let w:netrw_treedict[a:dirname]= getline(w:netrw_bannercnt,line("$")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9287 | " call Decho("w:treedict[".a:dirname."]= ".string(w:netrw_treedict[a:dirname]),'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9288 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.",$d _" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9289 | |
| 9290 | " if past banner, record word |
| 9291 | if exists("w:netrw_bannercnt") && line(".") > w:netrw_bannercnt |
| 9292 | let fname= expand("<cword>") |
| 9293 | else |
| 9294 | let fname= "" |
| 9295 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9296 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
| 9297 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9298 | |
| 9299 | " display from treetop on down |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9300 | NetrwKeepj call s:NetrwTreeDisplay(w:netrw_treetop,"") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9301 | " call Decho("s:NetrwTreeDisplay) setl noma nomod ro",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9302 | |
| 9303 | " remove any blank line remaining as line#1 (happens in treelisting mode with banner suppressed) |
| 9304 | while getline(1) =~ '^\s*$' && byte2line(1) > 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9305 | " call Decho("deleting blank line",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9306 | 1d |
| 9307 | endwhile |
| 9308 | |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 9309 | exe "setl ".g:netrw_bufsettings |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9310 | |
| 9311 | " call Dret("NetrwTreeListing : bufname<".expand("%").">") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 9312 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9313 | endif |
| 9314 | endfun |
| 9315 | |
| 9316 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9317 | " s:NetrwTreePath: returns path to current file/directory in tree listing {{{2 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9318 | " Normally, treetop is w:netrw_treetop, but a |
| 9319 | " user of the function ( netrw#SetTreetop() ) |
| 9320 | " wipes that out prior to calling this function |
| 9321 | fun! s:NetrwTreePath(treetop) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9322 | " call Dfunc("s:NetrwTreePath(treetop<".a:treetop.">) line#".line(".")."<".getline(".").">") |
| 9323 | if line(".") < w:netrw_bannercnt + 2 |
| 9324 | let treedir= a:treetop |
| 9325 | if treedir !~ '/$' |
| 9326 | let treedir= treedir.'/' |
| 9327 | endif |
| 9328 | " call Dret("s:NetrwTreePath ".treedir." : line#".line(".")." ≤ ".(w:netrw_bannercnt+2)) |
| 9329 | return treedir |
| 9330 | endif |
| 9331 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9332 | let svpos = winsaveview() |
| 9333 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9334 | let depth = substitute(getline('.'),'^\(\%('.s:treedepthstring.'\)*\)[^'.s:treedepthstring.'].\{-}$','\1','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9335 | " call Decho("depth<".depth."> 1st subst",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9336 | let depth = substitute(depth,'^'.s:treedepthstring,'','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9337 | " call Decho("depth<".depth."> 2nd subst (first depth removed)",'~'.expand("<slnum>")) |
| 9338 | let curline= getline('.') |
| 9339 | " call Decho("curline<".curline.'>','~'.expand("<slnum>")) |
| 9340 | if curline =~ '/$' |
| 9341 | " call Decho("extract tree directory from current line",'~'.expand("<slnum>")) |
| 9342 | let treedir= substitute(curline,'^\%('.s:treedepthstring.'\)*\([^'.s:treedepthstring.'].\{-}\)$','\1','e') |
| 9343 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
| 9344 | elseif curline =~ '@\s\+-->' |
| 9345 | " call Decho("extract tree directory using symbolic link",'~'.expand("<slnum>")) |
| 9346 | let treedir= substitute(curline,'^\%('.s:treedepthstring.'\)*\([^'.s:treedepthstring.'].\{-}\)$','\1','e') |
| 9347 | let treedir= substitute(treedir,'@\s\+-->.*$','','e') |
| 9348 | " call Decho("treedir<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9349 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9350 | " call Decho("do not extract tree directory from current line and set treedir to empty",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9351 | let treedir= "" |
| 9352 | endif |
| 9353 | " construct treedir by searching backwards at correct depth |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9354 | " call Decho("construct treedir by searching backwards for correct depth",'~'.expand("<slnum>")) |
| 9355 | " call Decho("initial treedir<".treedir."> depth<".depth.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9356 | while depth != "" && search('^'.depth.'[^'.s:treedepthstring.'].\{-}/$','bW') |
| 9357 | let dirname= substitute(getline('.'),'^\('.s:treedepthstring.'\)*','','e') |
| 9358 | let treedir= dirname.treedir |
| 9359 | let depth = substitute(depth,'^'.s:treedepthstring,'','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9360 | " call Decho("constructing treedir<".treedir.">: dirname<".dirname."> while depth<".depth.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9361 | endwhile |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9362 | " call Decho("treedir#1<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9363 | if a:treetop =~ '/$' |
| 9364 | let treedir= a:treetop.treedir |
| 9365 | else |
| 9366 | let treedir= a:treetop.'/'.treedir |
| 9367 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9368 | " call Decho("treedir#2<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9369 | let treedir= substitute(treedir,'//$','/','') |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9370 | " call Decho("treedir#3<".treedir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9371 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>"))" |
| 9372 | call winrestview(svpos) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9373 | " call Dret("s:NetrwTreePath <".treedir.">") |
| 9374 | return treedir |
| 9375 | endfun |
| 9376 | |
| 9377 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9378 | " s:NetrwWideListing: {{{2 |
| 9379 | fun! s:NetrwWideListing() |
| 9380 | |
| 9381 | if w:netrw_liststyle == s:WIDELIST |
| 9382 | " call Dfunc("NetrwWideListing() w:netrw_liststyle=".w:netrw_liststyle.' fo='.&fo.' l:fo='.&l:fo) |
| 9383 | " look for longest filename (cpf=characters per filename) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9384 | " cpf: characters per filename |
| 9385 | " fpl: filenames per line |
| 9386 | " fpc: filenames per column |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9387 | setl ma noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9388 | " call Decho("setl ma noro",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9389 | let b:netrw_cpf= 0 |
| 9390 | if line("$") >= w:netrw_bannercnt |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9391 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$g/^./if virtcol("$") > b:netrw_cpf|let b:netrw_cpf= virtcol("$")|endif' |
| 9392 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9393 | else |
| 9394 | " call Dret("NetrwWideListing") |
| 9395 | return |
| 9396 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9397 | let b:netrw_cpf= b:netrw_cpf + 2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9398 | " call Decho("b:netrw_cpf=max_filename_length+2=".b:netrw_cpf,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9399 | |
| 9400 | " determine qty files per line (fpl) |
| 9401 | let w:netrw_fpl= winwidth(0)/b:netrw_cpf |
| 9402 | if w:netrw_fpl <= 0 |
| 9403 | let w:netrw_fpl= 1 |
| 9404 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9405 | " call Decho("fpl= [winwidth=".winwidth(0)."]/[b:netrw_cpf=".b:netrw_cpf.']='.w:netrw_fpl,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9406 | |
| 9407 | " make wide display |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9408 | " fpc: files per column of wide listing |
| 9409 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$s/^.*$/\=escape(printf("%-'.b:netrw_cpf.'S",submatch(0)),"\\")/' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9410 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9411 | let fpc = (line("$") - w:netrw_bannercnt + w:netrw_fpl)/w:netrw_fpl |
| 9412 | let newcolstart = w:netrw_bannercnt + fpc |
| 9413 | let newcolend = newcolstart + fpc - 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9414 | " call Decho("bannercnt=".w:netrw_bannercnt." fpl=".w:netrw_fpl." fpc=".fpc." newcol[".newcolstart.",".newcolend."]",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9415 | if has("clipboard") |
| 9416 | sil! let keepregstar = @* |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9417 | sil! let keepregplus = @+ |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9418 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9419 | while line("$") >= newcolstart |
| 9420 | if newcolend > line("$") | let newcolend= line("$") | endif |
| 9421 | let newcolqty= newcolend - newcolstart |
| 9422 | exe newcolstart |
| 9423 | if newcolqty == 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9424 | exe "sil! NetrwKeepj norm! 0\<c-v>$hx".w:netrw_bannercnt."G$p" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9425 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9426 | exe "sil! NetrwKeepj norm! 0\<c-v>".newcolqty.'j$hx'.w:netrw_bannercnt.'G$p' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9427 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9428 | exe "sil! NetrwKeepj ".newcolstart.','.newcolend.'d _' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9429 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9430 | endwhile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9431 | if has("clipboard") |
| 9432 | sil! let @*= keepregstar |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9433 | sil! let @+= keepregplus |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9434 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9435 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.',$s/\s\+$//e' |
| 9436 | NetrwKeepj call histdel("/",-1) |
| 9437 | exe 'nno <buffer> <silent> w :call search(''^.\\|\s\s\zs\S'',''W'')'."\<cr>" |
| 9438 | exe 'nno <buffer> <silent> b :call search(''^.\\|\s\s\zs\S'',''bW'')'."\<cr>" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9439 | " call Decho("NetrwWideListing) setl noma nomod ro",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 9440 | exe "setl ".g:netrw_bufsettings |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9441 | " call Decho("(NetrwWideListing) ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9442 | " call Dret("NetrwWideListing") |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 9443 | return |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 9444 | else |
| 9445 | if hasmapto("w","n") |
| 9446 | sil! nunmap <buffer> w |
| 9447 | endif |
| 9448 | if hasmapto("b","n") |
| 9449 | sil! nunmap <buffer> b |
| 9450 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9451 | endif |
| 9452 | |
| 9453 | endfun |
| 9454 | |
| 9455 | " --------------------------------------------------------------------- |
| 9456 | " s:PerformListing: {{{2 |
| 9457 | fun! s:PerformListing(islocal) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9458 | " call Dfunc("s:PerformListing(islocal=".a:islocal.")") |
| 9459 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol()." line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9460 | " call Decho("settings: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (enter)"." ei<".&ei.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9461 | |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 9462 | " set up syntax highlighting {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9463 | " call Decho("--set up syntax highlighting (ie. setl ft=netrw)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9464 | sil! setl ft=netrw |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 9465 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9466 | NetrwKeepj call s:NetrwSafeOptions() |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9467 | setl noro ma |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9468 | " call Decho("setl noro ma bh=".&bh,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9469 | |
| 9470 | " if exists("g:netrw_silent") && g:netrw_silent == 0 && &ch >= 1 " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9471 | " call Decho("(netrw) Processing your browsing request...",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9472 | " endif " Decho |
| 9473 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9474 | " call Decho('w:netrw_liststyle='.(exists("w:netrw_liststyle")? w:netrw_liststyle : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9475 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST && exists("w:netrw_treedict") |
| 9476 | " force a refresh for tree listings |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9477 | " call Decho("force refresh for treelisting: clear buffer<".expand("%")."> with :%d",'~'.expand("<slnum>")) |
| 9478 | sil! NetrwKeepj %d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9479 | endif |
| 9480 | |
| 9481 | " save current directory on directory history list |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9482 | NetrwKeepj call s:NetrwBookHistHandler(3,b:netrw_curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9483 | |
| 9484 | " Set up the banner {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9485 | if g:netrw_banner |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9486 | " call Decho("--set up banner",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9487 | NetrwKeepj call setline(1,'" ============================================================================') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9488 | if exists("g:netrw_pchk") |
| 9489 | " this undocumented option allows pchk to run with different versions of netrw without causing spurious |
| 9490 | " failure detections. |
| 9491 | NetrwKeepj call setline(2,'" Netrw Directory Listing') |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 9492 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9493 | NetrwKeepj call setline(2,'" Netrw Directory Listing (netrw '.g:loaded_netrw.')') |
| 9494 | endif |
| 9495 | if exists("g:netrw_pchk") |
| 9496 | let curdir= substitute(b:netrw_curdir,expand("$HOME"),'~','') |
| 9497 | else |
| 9498 | let curdir= b:netrw_curdir |
| 9499 | endif |
| 9500 | if exists("g:netrw_bannerbackslash") && g:netrw_bannerbackslash |
| 9501 | NetrwKeepj call setline(3,'" '.substitute(curdir,'/','\\','g')) |
| 9502 | else |
| 9503 | NetrwKeepj call setline(3,'" '.curdir) |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 9504 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9505 | let w:netrw_bannercnt= 3 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9506 | NetrwKeepj exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9507 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9508 | " call Decho("--no banner",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9509 | NetrwKeepj 1 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9510 | let w:netrw_bannercnt= 1 |
| 9511 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9512 | " call Decho("w:netrw_bannercnt=".w:netrw_bannercnt." win#".winnr(),'~'.expand("<slnum>")) |
| 9513 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol()." line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9514 | |
| 9515 | let sortby= g:netrw_sort_by |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9516 | if g:netrw_sort_direction =~# "^r" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9517 | let sortby= sortby." reversed" |
| 9518 | endif |
| 9519 | |
| 9520 | " Sorted by... {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9521 | if g:netrw_banner |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9522 | " call Decho("--handle specified sorting: g:netrw_sort_by<".g:netrw_sort_by.">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9523 | if g:netrw_sort_by =~# "^n" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9524 | " call Decho("directories will be sorted by name",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9525 | " sorted by name |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9526 | NetrwKeepj put ='\" Sorted by '.sortby |
| 9527 | NetrwKeepj put ='\" Sort sequence: '.g:netrw_sort_sequence |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9528 | let w:netrw_bannercnt= w:netrw_bannercnt + 2 |
| 9529 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9530 | " call Decho("directories will be sorted by size or time",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9531 | " sorted by size or date |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9532 | NetrwKeepj put ='\" Sorted by '.sortby |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9533 | let w:netrw_bannercnt= w:netrw_bannercnt + 1 |
| 9534 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9535 | exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9536 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9537 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9538 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9539 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9540 | " show copy/move target, if any {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9541 | if g:netrw_banner |
| 9542 | if exists("s:netrwmftgt") && exists("s:netrwmftgt_islocal") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9543 | " call Decho("--show copy/move target<".s:netrwmftgt.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9544 | NetrwKeepj put ='' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9545 | if s:netrwmftgt_islocal |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9546 | sil! NetrwKeepj call setline(line("."),'" Copy/Move Tgt: '.s:netrwmftgt.' (local)') |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9547 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9548 | sil! NetrwKeepj call setline(line("."),'" Copy/Move Tgt: '.s:netrwmftgt.' (remote)') |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9549 | endif |
| 9550 | let w:netrw_bannercnt= w:netrw_bannercnt + 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9551 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9552 | " call Decho("s:netrwmftgt does not exist, don't make Copy/Move Tgt",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9553 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9554 | exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9555 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9556 | |
| 9557 | " Hiding... -or- Showing... {{{3 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9558 | if g:netrw_banner |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9559 | " call Decho("--handle hiding/showing (g:netrw_hide=".g:netrw_list_hide." g:netrw_list_hide<".g:netrw_list_hide.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9560 | if g:netrw_list_hide != "" && g:netrw_hide |
| 9561 | if g:netrw_hide == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9562 | NetrwKeepj put ='\" Hiding: '.g:netrw_list_hide |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9563 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9564 | NetrwKeepj put ='\" Showing: '.g:netrw_list_hide |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9565 | endif |
| 9566 | let w:netrw_bannercnt= w:netrw_bannercnt + 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9567 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9568 | exe "NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9569 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9570 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9571 | let quickhelp = g:netrw_quickhelp%len(s:QuickHelp) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9572 | " call Decho("quickhelp =".quickhelp,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9573 | NetrwKeepj put ='\" Quick Help: <F1>:help '.s:QuickHelp[quickhelp] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9574 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9575 | NetrwKeepj put ='\" ==============================================================================' |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9576 | let w:netrw_bannercnt= w:netrw_bannercnt + 2 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9577 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9578 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9579 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9580 | |
| 9581 | " bannercnt should index the line just after the banner |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9582 | if g:netrw_banner |
| 9583 | let w:netrw_bannercnt= w:netrw_bannercnt + 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9584 | exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9585 | " call Decho("--w:netrw_bannercnt=".w:netrw_bannercnt." (should index line just after banner) line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9586 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9587 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9588 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9589 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9590 | " get list of files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9591 | " call Decho("--Get list of files - islocal=".a:islocal,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9592 | if a:islocal |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9593 | NetrwKeepj call s:LocalListing() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9594 | else " remote |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9595 | NetrwKeepj let badresult= s:NetrwRemoteListing() |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9596 | if badresult |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9597 | " call Decho("w:netrw_bannercnt=".(exists("w:netrw_bannercnt")? w:netrw_bannercnt : 'n/a')." win#".winnr()." buf#".bufnr("%")."<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9598 | " call Dret("s:PerformListing : error detected by NetrwRemoteListing") |
| 9599 | return |
| 9600 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9601 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9602 | |
| 9603 | " manipulate the directory listing (hide, sort) {{{3 |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 9604 | if !exists("w:netrw_bannercnt") |
| 9605 | let w:netrw_bannercnt= 0 |
| 9606 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9607 | " call Decho("--manipulate directory listing (hide, sort)",'~'.expand("<slnum>")) |
| 9608 | " call Decho("g:netrw_banner=".g:netrw_banner." w:netrw_bannercnt=".w:netrw_bannercnt." (banner complete)",'~'.expand("<slnum>")) |
| 9609 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9610 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9611 | if !g:netrw_banner || line("$") >= w:netrw_bannercnt |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9612 | " call Decho("manipulate directory listing (hide)",'~'.expand("<slnum>")) |
| 9613 | " call Decho("g:netrw_hide=".g:netrw_hide." g:netrw_list_hide<".g:netrw_list_hide.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9614 | if g:netrw_hide && g:netrw_list_hide != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9615 | NetrwKeepj call s:NetrwListHide() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9616 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9617 | if !g:netrw_banner || line("$") >= w:netrw_bannercnt |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9618 | " call Decho("manipulate directory listing (sort) : g:netrw_sort_by<".g:netrw_sort_by.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9619 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9620 | if g:netrw_sort_by =~# "^n" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9621 | " sort by name |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9622 | NetrwKeepj call s:NetrwSetSort() |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9623 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9624 | if !g:netrw_banner || w:netrw_bannercnt < line("$") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9625 | " call Decho("g:netrw_sort_direction=".g:netrw_sort_direction." (bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9626 | if g:netrw_sort_direction =~# 'n' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9627 | " normal direction sorting |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9628 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$sort'.' '.g:netrw_sort_options |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9629 | else |
| 9630 | " reverse direction sorting |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9631 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$sort!'.' '.g:netrw_sort_options |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9632 | endif |
| 9633 | endif |
| 9634 | " remove priority pattern prefix |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9635 | " call Decho("remove priority pattern prefix",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9636 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^\d\{3}'.g:netrw_sepchr.'//e' |
| 9637 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9638 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9639 | elseif g:netrw_sort_by =~# "^ext" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9640 | " sort by extension |
| 9641 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$g+/+s/^/001'.g:netrw_sepchr.'/' |
| 9642 | NetrwKeepj call histdel("/",-1) |
| 9643 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$v+[./]+s/^/002'.g:netrw_sepchr.'/' |
| 9644 | NetrwKeepj call histdel("/",-1) |
| 9645 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$v+['.g:netrw_sepchr.'/]+s/^\(.*\.\)\(.\{-\}\)$/\2'.g:netrw_sepchr.'&/e' |
| 9646 | NetrwKeepj call histdel("/",-1) |
| 9647 | if !g:netrw_banner || w:netrw_bannercnt < line("$") |
| 9648 | " call Decho("g:netrw_sort_direction=".g:netrw_sort_direction." (bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9649 | if g:netrw_sort_direction =~# 'n' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9650 | " normal direction sorting |
| 9651 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$sort'.' '.g:netrw_sort_options |
| 9652 | else |
| 9653 | " reverse direction sorting |
| 9654 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$sort!'.' '.g:netrw_sort_options |
| 9655 | endif |
| 9656 | endif |
| 9657 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^.\{-}'.g:netrw_sepchr.'//e' |
| 9658 | NetrwKeepj call histdel("/",-1) |
| 9659 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9660 | elseif a:islocal |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9661 | if !g:netrw_banner || w:netrw_bannercnt < line("$") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9662 | " call Decho("g:netrw_sort_direction=".g:netrw_sort_direction,'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9663 | if g:netrw_sort_direction =~# 'n' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9664 | " call Decho('exe sil NetrwKeepj '.w:netrw_bannercnt.',$sort','~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9665 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$sort'.' '.g:netrw_sort_options |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9666 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9667 | " call Decho('exe sil NetrwKeepj '.w:netrw_bannercnt.',$sort!','~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9668 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$sort!'.' '.g:netrw_sort_options |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9669 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9670 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^\d\{-}\///e' |
| 9671 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9672 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9673 | endif |
| 9674 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9675 | elseif g:netrw_sort_direction =~# 'r' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9676 | " call Decho('(s:PerformListing) reverse the sorted listing','~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9677 | if !g:netrw_banner || w:netrw_bannercnt < line('$') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9678 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$g/^/m '.w:netrw_bannercnt |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 9679 | call histdel("/",-1) |
| 9680 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9681 | endif |
| 9682 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9683 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9684 | |
| 9685 | " convert to wide/tree listing {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9686 | " call Decho("--modify display if wide/tree listing style",'~'.expand("<slnum>")) |
| 9687 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#1)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9688 | NetrwKeepj call s:NetrwWideListing() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9689 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#2)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9690 | NetrwKeepj call s:NetrwTreeListing(b:netrw_curdir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9691 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#3)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9692 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9693 | " resolve symbolic links if local and (thin or tree) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9694 | if a:islocal && (w:netrw_liststyle == s:THINLIST || (exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST)) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9695 | " call Decho("--resolve symbolic links if local and thin|tree",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9696 | sil! g/@$/call s:ShowLink() |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9697 | endif |
| 9698 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9699 | if exists("w:netrw_bannercnt") && (line("$") >= w:netrw_bannercnt || !g:netrw_banner) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9700 | " place cursor on the top-left corner of the file listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9701 | " call Decho("--place cursor on top-left corner of file listing",'~'.expand("<slnum>")) |
| 9702 | exe 'sil! '.w:netrw_bannercnt |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9703 | sil! NetrwKeepj norm! 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9704 | " call Decho(" tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol()." line($)=".line("$"),'~'.expand("<slnum>")) |
| 9705 | else |
| 9706 | " call Decho("--did NOT place cursor on top-left corner",'~'.expand("<slnum>")) |
| 9707 | " call Decho(" w:netrw_bannercnt=".(exists("w:netrw_bannercnt")? w:netrw_bannercnt : 'n/a'),'~'.expand("<slnum>")) |
| 9708 | " call Decho(" line($)=".line("$"),'~'.expand("<slnum>")) |
| 9709 | " call Decho(" g:netrw_banner=".(exists("g:netrw_banner")? g:netrw_banner : 'n/a'),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9710 | endif |
| 9711 | |
| 9712 | " record previous current directory |
| 9713 | let w:netrw_prvdir= b:netrw_curdir |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9714 | " call Decho("--record netrw_prvdir<".w:netrw_prvdir.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9715 | |
| 9716 | " save certain window-oriented variables into buffer-oriented variables {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9717 | " call Decho("--save some window-oriented variables into buffer oriented variables",'~'.expand("<slnum>")) |
| 9718 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#4)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9719 | NetrwKeepj call s:SetBufWinVars() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9720 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#5)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9721 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9722 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#6)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9723 | |
| 9724 | " set display to netrw display settings |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9725 | " call Decho("--set display to netrw display settings (".g:netrw_bufsettings.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 9726 | exe "setl ".g:netrw_bufsettings |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9727 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#7)",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 9728 | if g:netrw_liststyle == s:LONGLIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9729 | " call Decho("exe setl ts=".(g:netrw_maxfilenamelen+1),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 9730 | exe "setl ts=".(g:netrw_maxfilenamelen+1) |
| 9731 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9732 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9733 | if exists("s:treecurpos") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9734 | " call Decho("s:treecurpos exists; restore posn",'~'.expand("<slnum>")) |
| 9735 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (internal#8)",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9736 | " call Decho("restoring posn to s:treecurpos<".string(s:treecurpos).">",'~'.expand("<slnum>")) |
| 9737 | NetrwKeepj call winrestview(s:treecurpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9738 | unlet s:treecurpos |
| 9739 | endif |
| 9740 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9741 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo. " (return)",'~'.expand("<slnum>")) |
| 9742 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol()." line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9743 | " call Dret("s:PerformListing : curpos<".string(getpos(".")).">") |
| 9744 | endfun |
| 9745 | |
| 9746 | " --------------------------------------------------------------------- |
| 9747 | " s:SetupNetrwStatusLine: {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 9748 | fun! s:SetupNetrwStatusLine(statline) |
| 9749 | " call Dfunc("SetupNetrwStatusLine(statline<".a:statline.">)") |
| 9750 | |
| 9751 | if !exists("s:netrw_setup_statline") |
| 9752 | let s:netrw_setup_statline= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9753 | " call Decho("do first-time status line setup",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 9754 | |
| 9755 | if !exists("s:netrw_users_stl") |
| 9756 | let s:netrw_users_stl= &stl |
| 9757 | endif |
| 9758 | if !exists("s:netrw_users_ls") |
| 9759 | let s:netrw_users_ls= &laststatus |
| 9760 | endif |
| 9761 | |
| 9762 | " set up User9 highlighting as needed |
| 9763 | let keepa= @a |
| 9764 | redir @a |
| 9765 | try |
| 9766 | hi User9 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9767 | catch /^Vim\%((\a\{3,})\)\=:E411/ |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 9768 | if &bg == "dark" |
| 9769 | hi User9 ctermfg=yellow ctermbg=blue guifg=yellow guibg=blue |
| 9770 | else |
| 9771 | hi User9 ctermbg=yellow ctermfg=blue guibg=yellow guifg=blue |
| 9772 | endif |
| 9773 | endtry |
| 9774 | redir END |
| 9775 | let @a= keepa |
| 9776 | endif |
| 9777 | |
| 9778 | " set up status line (may use User9 highlighting) |
| 9779 | " insure that windows have a statusline |
| 9780 | " make sure statusline is displayed |
| 9781 | let &stl=a:statline |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 9782 | setl laststatus=2 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9783 | " call Decho("stl=".&stl,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9784 | redraw |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 9785 | |
| 9786 | " call Dret("SetupNetrwStatusLine : stl=".&stl) |
| 9787 | endfun |
| 9788 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 9789 | " ========================================= |
| 9790 | " Remote Directory Browsing Support: {{{1 |
| 9791 | " ========================================= |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 9792 | |
| 9793 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9794 | " s:NetrwRemoteFtpCmd: unfortunately, not all ftp servers honor options for ls {{{2 |
| 9795 | " This function assumes that a long listing will be received. Size, time, |
| 9796 | " and reverse sorts will be requested of the server but not otherwise |
| 9797 | " enforced here. |
| 9798 | fun! s:NetrwRemoteFtpCmd(path,listcmd) |
| 9799 | " call Dfunc("NetrwRemoteFtpCmd(path<".a:path."> listcmd<".a:listcmd.">) w:netrw_method=".(exists("w:netrw_method")? w:netrw_method : (exists("b:netrw_method")? b:netrw_method : "???"))) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9800 | " call Decho("line($)=".line("$")." win#".winnr()." w:netrw_bannercnt=".w:netrw_bannercnt,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9801 | " sanity check: {{{3 |
| 9802 | if !exists("w:netrw_method") |
| 9803 | if exists("b:netrw_method") |
| 9804 | let w:netrw_method= b:netrw_method |
| 9805 | else |
| 9806 | call netrw#ErrorMsg(2,"(s:NetrwRemoteFtpCmd) internal netrw error",93) |
| 9807 | " call Dret("NetrwRemoteFtpCmd") |
| 9808 | return |
| 9809 | endif |
| 9810 | endif |
| 9811 | |
| 9812 | " WinXX ftp uses unix style input, so set ff to unix " {{{3 |
| 9813 | let ffkeep= &ff |
| 9814 | setl ma ff=unix noro |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9815 | " call Decho("setl ma ff=unix noro",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9816 | |
| 9817 | " clear off any older non-banner lines " {{{3 |
| 9818 | " note that w:netrw_bannercnt indexes the line after the banner |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9819 | " call Decho('exe sil! NetrwKeepj '.w:netrw_bannercnt.",$d _ (clear off old non-banner lines)",'~'.expand("<slnum>")) |
| 9820 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.",$d _" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9821 | |
| 9822 | "......................................... |
| 9823 | if w:netrw_method == 2 || w:netrw_method == 5 " {{{3 |
| 9824 | " ftp + <.netrc>: Method #2 |
| 9825 | if a:path != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9826 | NetrwKeepj put ='cd \"'.a:path.'\"' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9827 | endif |
| 9828 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9829 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9830 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9831 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9832 | NetrwKeepj call setline(line("$")+1,a:listcmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9833 | " exe "NetrwKeepj ".w:netrw_bannercnt.',$g/^./call Decho("ftp#".line(".").": ".getline("."),''~''.expand("<slnum>"))' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9834 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9835 | " call Decho("exe ".s:netrw_silentxfer.w:netrw_bannercnt.",$!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1),'~'.expand("<slnum>")) |
| 9836 | exe s:netrw_silentxfer." NetrwKeepj ".w:netrw_bannercnt.",$!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1)." ".s:ShellEscape(g:netrw_port,1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9837 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9838 | " call Decho("exe ".s:netrw_silentxfer.w:netrw_bannercnt.",$!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1),'~'.expand("<slnum>")) |
| 9839 | exe s:netrw_silentxfer." NetrwKeepj ".w:netrw_bannercnt.",$!".s:netrw_ftp_cmd." -i ".s:ShellEscape(g:netrw_machine,1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9840 | endif |
| 9841 | |
| 9842 | "......................................... |
| 9843 | elseif w:netrw_method == 3 " {{{3 |
| 9844 | " ftp + machine,id,passwd,filename: Method #3 |
| 9845 | setl ff=unix |
| 9846 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9847 | NetrwKeepj put ='open '.g:netrw_machine.' '.g:netrw_port |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9848 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9849 | NetrwKeepj put ='open '.g:netrw_machine |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9850 | endif |
| 9851 | |
| 9852 | " handle userid and password |
| 9853 | let host= substitute(g:netrw_machine,'\..*$','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9854 | " call Decho("host<".host.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9855 | if exists("s:netrw_hup") && exists("s:netrw_hup[host]") |
| 9856 | call NetUserPass("ftp:".host) |
| 9857 | endif |
| 9858 | if exists("g:netrw_uid") && g:netrw_uid != "" |
| 9859 | if exists("g:netrw_ftp") && g:netrw_ftp == 1 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9860 | NetrwKeepj put =g:netrw_uid |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9861 | if exists("s:netrw_passwd") && s:netrw_passwd != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9862 | NetrwKeepj put ='\"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9863 | endif |
| 9864 | elseif exists("s:netrw_passwd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9865 | NetrwKeepj put ='user \"'.g:netrw_uid.'\" \"'.s:netrw_passwd.'\"' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9866 | endif |
| 9867 | endif |
| 9868 | |
| 9869 | if a:path != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9870 | NetrwKeepj put ='cd \"'.a:path.'\"' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9871 | endif |
| 9872 | if exists("g:netrw_ftpextracmd") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9873 | NetrwKeepj put =g:netrw_ftpextracmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9874 | " call Decho("filter input: ".getline('.'),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9875 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9876 | NetrwKeepj call setline(line("$")+1,a:listcmd) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9877 | |
| 9878 | " perform ftp: |
| 9879 | " -i : turns off interactive prompting from ftp |
| 9880 | " -n unix : DON'T use <.netrc>, even though it exists |
| 9881 | " -n win32: quit being obnoxious about password |
| 9882 | if exists("w:netrw_bannercnt") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9883 | " exe w:netrw_bannercnt.',$g/^./call Decho("ftp#".line(".").": ".getline("."),''~''.expand("<slnum>"))' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9884 | call s:NetrwExe(s:netrw_silentxfer.w:netrw_bannercnt.",$!".s:netrw_ftp_cmd." ".g:netrw_ftp_options) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9885 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9886 | " call Decho("WARNING: w:netrw_bannercnt doesn't exist!",'~'.expand("<slnum>")) |
| 9887 | " g/^./call Decho("SKIPPING ftp#".line(".").": ".getline("."),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9888 | endif |
| 9889 | |
| 9890 | "......................................... |
| 9891 | elseif w:netrw_method == 9 " {{{3 |
| 9892 | " sftp username@machine: Method #9 |
| 9893 | " s:netrw_sftp_cmd |
| 9894 | setl ff=unix |
| 9895 | |
| 9896 | " restore settings |
| 9897 | let &ff= ffkeep |
| 9898 | " call Dret("NetrwRemoteFtpCmd") |
| 9899 | return |
| 9900 | |
| 9901 | "......................................... |
| 9902 | else " {{{3 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9903 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"unable to comply with your request<" . bufname("%") . ">",23) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9904 | endif |
| 9905 | |
| 9906 | " cleanup for Windows " {{{3 |
| 9907 | if has("win32") || has("win95") || has("win64") || has("win16") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9908 | sil! NetrwKeepj %s/\r$//e |
| 9909 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9910 | endif |
| 9911 | if a:listcmd == "dir" |
| 9912 | " infer directory/link based on the file permission string |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9913 | sil! NetrwKeepj g/d\%([-r][-w][-x]\)\{3}/NetrwKeepj s@$@/@e |
| 9914 | sil! NetrwKeepj g/l\%([-r][-w][-x]\)\{3}/NetrwKeepj s/$/@/e |
| 9915 | NetrwKeepj call histdel("/",-1) |
| 9916 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9917 | if w:netrw_liststyle == s:THINLIST || w:netrw_liststyle == s:WIDELIST || (exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9918 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.',$s/^\%(\S\+\s\+\)\{8}//e' |
| 9919 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9920 | endif |
| 9921 | endif |
| 9922 | |
| 9923 | " ftp's listing doesn't seem to include ./ or ../ " {{{3 |
| 9924 | if !search('^\.\/$\|\s\.\/$','wn') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9925 | exe 'NetrwKeepj '.w:netrw_bannercnt |
| 9926 | NetrwKeepj put ='./' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9927 | endif |
| 9928 | if !search('^\.\.\/$\|\s\.\.\/$','wn') |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9929 | exe 'NetrwKeepj '.w:netrw_bannercnt |
| 9930 | NetrwKeepj put ='../' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9931 | endif |
| 9932 | |
| 9933 | " restore settings " {{{3 |
| 9934 | let &ff= ffkeep |
| 9935 | " call Dret("NetrwRemoteFtpCmd") |
| 9936 | endfun |
| 9937 | |
| 9938 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9939 | " s:NetrwRemoteListing: {{{2 |
| 9940 | fun! s:NetrwRemoteListing() |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 9941 | " call Dfunc("s:NetrwRemoteListing() b:netrw_curdir<".b:netrw_curdir.">) win#".winnr()) |
Bram Moolenaar | 69a7cb4 | 2004-06-20 12:51:53 +0000 | [diff] [blame] | 9942 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9943 | if !exists("w:netrw_bannercnt") && exists("s:bannercnt") |
| 9944 | let w:netrw_bannercnt= s:bannercnt |
| 9945 | endif |
| 9946 | if !exists("w:netrw_bannercnt") && exists("b:bannercnt") |
| 9947 | let w:netrw_bannercnt= s:bannercnt |
| 9948 | endif |
| 9949 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9950 | call s:RemotePathAnalysis(b:netrw_curdir) |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 9951 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9952 | " sanity check: |
| 9953 | if exists("b:netrw_method") && b:netrw_method =~ '[235]' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9954 | " call Decho("b:netrw_method=".b:netrw_method,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9955 | if !executable("ftp") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9956 | " call Decho("ftp is not executable",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9957 | if !exists("g:netrw_quiet") |
| 9958 | call netrw#ErrorMsg(s:ERROR,"this system doesn't support remote directory listing via ftp",18) |
| 9959 | endif |
| 9960 | call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9961 | " call Dret("s:NetrwRemoteListing -1") |
| 9962 | return -1 |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 9963 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9964 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9965 | elseif !exists("g:netrw_list_cmd") || g:netrw_list_cmd == '' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9966 | " call Decho("g:netrw_list_cmd<",(exists("g:netrw_list_cmd")? 'n/a' : "-empty-").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9967 | if !exists("g:netrw_quiet") |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9968 | if g:netrw_list_cmd == "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9969 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"your g:netrw_list_cmd is empty; perhaps ".g:netrw_ssh_cmd." is not executable on your system",47) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9970 | else |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9971 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"this system doesn't support remote directory listing via ".g:netrw_list_cmd,19) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9972 | endif |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 9973 | endif |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 9974 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 9975 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 9976 | " call Dret("s:NetrwRemoteListing -1") |
| 9977 | return -1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9978 | endif " (remote handling sanity check) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9979 | " call Decho("passed remote listing sanity checks",'~'.expand("<slnum>")) |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 9980 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9981 | if exists("b:netrw_method") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9982 | " call Decho("setting w:netrw_method to b:netrw_method<".b:netrw_method.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9983 | let w:netrw_method= b:netrw_method |
| 9984 | endif |
| 9985 | |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 9986 | if s:method == "ftp" |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 9987 | " use ftp to get remote file listing {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9988 | " call Decho("use ftp to get remote file listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 9989 | let s:method = "ftp" |
| 9990 | let listcmd = g:netrw_ftp_list_cmd |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9991 | if g:netrw_sort_by =~# '^t' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9992 | let listcmd= g:netrw_ftp_timelist_cmd |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 9993 | elseif g:netrw_sort_by =~# '^s' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9994 | let listcmd= g:netrw_ftp_sizelist_cmd |
| 9995 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9996 | " call Decho("listcmd<".listcmd."> (using g:netrw_ftp_list_cmd)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9997 | call s:NetrwRemoteFtpCmd(s:path,listcmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 9998 | " exe "sil! keepalt NetrwKeepj ".w:netrw_bannercnt.',$g/^./call Decho("raw listing: ".getline("."),''~''.expand("<slnum>"))' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 9999 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10000 | " report on missing file or directory messages |
| 10001 | if search('[Nn]o such file or directory\|Failed to change directory') |
| 10002 | let mesg= getline(".") |
| 10003 | if exists("w:netrw_bannercnt") |
| 10004 | setl ma |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10005 | exe w:netrw_bannercnt.",$d _" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10006 | setl noma |
| 10007 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10008 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10009 | call netrw#ErrorMsg(s:WARNING,mesg,96) |
| 10010 | " call Dret("s:NetrwRemoteListing : -1") |
| 10011 | return -1 |
| 10012 | endif |
| 10013 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10014 | if w:netrw_liststyle == s:THINLIST || w:netrw_liststyle == s:WIDELIST || (exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10015 | " shorten the listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10016 | " call Decho("generate short listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10017 | exe "sil! keepalt NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10018 | |
| 10019 | " cleanup |
| 10020 | if g:netrw_ftp_browse_reject != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10021 | exe "sil! keepalt NetrwKeepj g/".g:netrw_ftp_browse_reject."/NetrwKeepj d" |
| 10022 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10023 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10024 | sil! NetrwKeepj %s/\r$//e |
| 10025 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10026 | |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 10027 | " if there's no ../ listed, then put ../ in |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10028 | let line1= line(".") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10029 | exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10030 | let line2= search('\.\.\/\%(\s\|$\)','cnW') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10031 | " call Decho("search(".'\.\.\/\%(\s\|$\)'."','cnW')=".line2." w:netrw_bannercnt=".w:netrw_bannercnt,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10032 | if line2 == 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10033 | " call Decho("netrw is putting ../ into listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10034 | sil! NetrwKeepj put='../' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10035 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10036 | exe "sil! NetrwKeepj ".line1 |
| 10037 | sil! NetrwKeepj norm! 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10038 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10039 | " call Decho("line1=".line1." line2=".line2." line(.)=".line("."),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10040 | if search('^\d\{2}-\d\{2}-\d\{2}\s','n') " M$ ftp site cleanup |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10041 | " call Decho("M$ ftp cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10042 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^\d\{2}-\d\{2}-\d\{2}\s\+\d\+:\d\+[AaPp][Mm]\s\+\%(<DIR>\|\d\+\)\s\+//' |
| 10043 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10044 | else " normal ftp cleanup |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10045 | " call Decho("normal ftp cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10046 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^\(\%(\S\+\s\+\)\{7}\S\+\)\s\+\(\S.*\)$/\2/e' |
| 10047 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.',$g/ -> /s# -> .*/$#/#e' |
| 10048 | exe "sil! NetrwKeepj ".w:netrw_bannercnt.',$g/ -> /s# -> .*$#/#e' |
| 10049 | NetrwKeepj call histdel("/",-1) |
| 10050 | NetrwKeepj call histdel("/",-1) |
| 10051 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10052 | endif |
| 10053 | endif |
| 10054 | |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 10055 | else |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10056 | " use ssh to get remote file listing {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10057 | " call Decho("use ssh to get remote file listing: s:path<".s:path.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10058 | let listcmd= s:MakeSshCmd(g:netrw_list_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10059 | " call Decho("listcmd<".listcmd."> (using g:netrw_list_cmd)",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10060 | if g:netrw_scp_cmd =~ '^pscp' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10061 | " call Decho("1: exe r! ".s:ShellEscape(listcmd.s:path, 1),'~'.expand("<slnum>")) |
| 10062 | exe "NetrwKeepj r! ".listcmd.s:ShellEscape(s:path, 1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10063 | " remove rubbish and adjust listing format of 'pscp' to 'ssh ls -FLa' like |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10064 | sil! NetrwKeepj g/^Listing directory/NetrwKeepj d |
| 10065 | sil! NetrwKeepj g/^d[-rwx][-rwx][-rwx]/NetrwKeepj s+$+/+e |
| 10066 | sil! NetrwKeepj g/^l[-rwx][-rwx][-rwx]/NetrwKeepj s+$+@+e |
| 10067 | NetrwKeepj call histdel("/",-1) |
| 10068 | NetrwKeepj call histdel("/",-1) |
| 10069 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10070 | if g:netrw_liststyle != s:LONGLIST |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10071 | sil! NetrwKeepj g/^[dlsp-][-rwx][-rwx][-rwx]/NetrwKeepj s/^.*\s\(\S\+\)$/\1/e |
| 10072 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10073 | endif |
| 10074 | else |
| 10075 | if s:path == "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10076 | " call Decho("2: exe r! ".listcmd,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10077 | exe "NetrwKeepj keepalt r! ".listcmd |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10078 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10079 | " call Decho("3: exe r! ".listcmd.' '.s:ShellEscape(fnameescape(s:path),1),'~'.expand("<slnum>")) |
| 10080 | exe "NetrwKeepj keepalt r! ".listcmd.' '.s:ShellEscape(fnameescape(s:path),1) |
| 10081 | " call Decho("listcmd<".listcmd."> path<".s:path.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10082 | endif |
| 10083 | endif |
| 10084 | |
| 10085 | " cleanup |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10086 | if g:netrw_ssh_browse_reject != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10087 | " call Decho("cleanup: exe sil! g/".g:netrw_ssh_browse_reject."/NetrwKeepj d",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10088 | exe "sil! g/".g:netrw_ssh_browse_reject."/NetrwKeepj d" |
| 10089 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10090 | endif |
| 10091 | endif |
| 10092 | |
| 10093 | if w:netrw_liststyle == s:LONGLIST |
| 10094 | " do a long listing; these substitutions need to be done prior to sorting {{{3 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10095 | " call Decho("fix long listing:",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10096 | |
| 10097 | if s:method == "ftp" |
| 10098 | " cleanup |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10099 | exe "sil! NetrwKeepj ".w:netrw_bannercnt |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10100 | while getline('.') =~# g:netrw_ftp_browse_reject |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10101 | sil! NetrwKeepj d |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10102 | endwhile |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 10103 | " if there's no ../ listed, then put ../ in |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10104 | let line1= line(".") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10105 | sil! NetrwKeepj 1 |
| 10106 | sil! NetrwKeepj call search('^\.\.\/\%(\s\|$\)','W') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10107 | let line2= line(".") |
| 10108 | if line2 == 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10109 | if b:netrw_curdir != '/' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10110 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt."put='../'" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10111 | endif |
| 10112 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10113 | exe "sil! NetrwKeepj ".line1 |
| 10114 | sil! NetrwKeepj norm! 0 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10115 | endif |
| 10116 | |
| 10117 | if search('^\d\{2}-\d\{2}-\d\{2}\s','n') " M$ ftp site cleanup |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10118 | " call Decho("M$ ftp site listing cleanup",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10119 | exe 'sil! NetrwKeepj '.w:netrw_bannercnt.',$s/^\(\d\{2}-\d\{2}-\d\{2}\s\+\d\+:\d\+[AaPp][Mm]\s\+\%(<DIR>\|\d\+\)\s\+\)\(\w.*\)$/\2\t\1/' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10120 | elseif exists("w:netrw_bannercnt") && w:netrw_bannercnt <= line("$") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10121 | " call Decho("normal ftp site listing cleanup: bannercnt=".w:netrw_bannercnt." line($)=".line("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10122 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$s/ -> .*$//e' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10123 | exe 'sil NetrwKeepj '.w:netrw_bannercnt.',$s/^\(\%(\S\+\s\+\)\{7}\S\+\)\s\+\(\S.*\)$/\2 \t\1/e' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10124 | exe 'sil NetrwKeepj '.w:netrw_bannercnt |
| 10125 | NetrwKeepj call histdel("/",-1) |
| 10126 | NetrwKeepj call histdel("/",-1) |
| 10127 | NetrwKeepj call histdel("/",-1) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10128 | endif |
| 10129 | endif |
| 10130 | |
| 10131 | " if exists("w:netrw_bannercnt") && w:netrw_bannercnt <= line("$") " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10132 | " exe "NetrwKeepj ".w:netrw_bannercnt.',$g/^./call Decho("listing: ".getline("."),''~''.expand("<slnum>"))' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10133 | " endif " Decho |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10134 | |
| 10135 | " call Dret("s:NetrwRemoteListing 0") |
| 10136 | return 0 |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 10137 | endfun |
| 10138 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10139 | " --------------------------------------------------------------------- |
| 10140 | " s:NetrwRemoteRm: remove/delete a remote file or directory {{{2 |
| 10141 | fun! s:NetrwRemoteRm(usrhost,path) range |
| 10142 | " call Dfunc("s:NetrwRemoteRm(usrhost<".a:usrhost."> path<".a:path.">) virtcol=".virtcol(".")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10143 | " call Decho("firstline=".a:firstline." lastline=".a:lastline,'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10144 | let svpos= winsaveview() |
| 10145 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10146 | |
| 10147 | let all= 0 |
| 10148 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
| 10149 | " remove all marked files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10150 | " call Decho("remove all marked files with bufnr#".bufnr("%"),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10151 | for fname in s:netrwmarkfilelist_{bufnr("%")} |
| 10152 | let ok= s:NetrwRemoteRmFile(a:path,fname,all) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10153 | if ok =~# 'q\%[uit]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10154 | break |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10155 | elseif ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10156 | let all= 1 |
| 10157 | endif |
| 10158 | endfor |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10159 | call s:NetrwUnmarkList(bufnr("%"),b:netrw_curdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10160 | |
| 10161 | else |
| 10162 | " remove files specified by range |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10163 | " call Decho("remove files specified by range",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10164 | |
| 10165 | " preparation for removing multiple files/directories |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10166 | let keepsol = &l:sol |
| 10167 | setl nosol |
| 10168 | let ctr = a:firstline |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10169 | |
| 10170 | " remove multiple files and directories |
| 10171 | while ctr <= a:lastline |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10172 | exe "NetrwKeepj ".ctr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10173 | let ok= s:NetrwRemoteRmFile(a:path,s:NetrwGetWord(),all) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10174 | if ok =~# 'q\%[uit]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10175 | break |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10176 | elseif ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10177 | let all= 1 |
| 10178 | endif |
| 10179 | let ctr= ctr + 1 |
| 10180 | endwhile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10181 | let &l:sol = keepsol |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10182 | endif |
| 10183 | |
| 10184 | " refresh the (remote) directory listing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10185 | " call Decho("refresh remote directory listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10186 | NetrwKeepj call s:NetrwRefresh(0,s:NetrwBrowseChgDir(0,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10187 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 10188 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10189 | |
| 10190 | " call Dret("s:NetrwRemoteRm") |
| 10191 | endfun |
| 10192 | |
| 10193 | " --------------------------------------------------------------------- |
| 10194 | " s:NetrwRemoteRmFile: {{{2 |
| 10195 | fun! s:NetrwRemoteRmFile(path,rmfile,all) |
| 10196 | " call Dfunc("s:NetrwRemoteRmFile(path<".a:path."> rmfile<".a:rmfile.">) all=".a:all) |
| 10197 | |
| 10198 | let all= a:all |
| 10199 | let ok = "" |
| 10200 | |
| 10201 | if a:rmfile !~ '^"' && (a:rmfile =~ '@$' || a:rmfile !~ '[\/]$') |
| 10202 | " attempt to remove file |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10203 | " call Decho("attempt to remove file (all=".all.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10204 | if !all |
| 10205 | echohl Statement |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10206 | " call Decho("case all=0:",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10207 | call inputsave() |
| 10208 | let ok= input("Confirm deletion of file<".a:rmfile."> ","[{y(es)},n(o),a(ll),q(uit)] ") |
| 10209 | call inputrestore() |
| 10210 | echohl NONE |
| 10211 | if ok == "" |
| 10212 | let ok="no" |
| 10213 | endif |
| 10214 | let ok= substitute(ok,'\[{y(es)},n(o),a(ll),q(uit)]\s*','','e') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10215 | if ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10216 | let all= 1 |
| 10217 | endif |
| 10218 | endif |
| 10219 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10220 | if all || ok =~# 'y\%[es]' || ok == "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10221 | " call Decho("case all=".all." or ok<".ok.">".(exists("w:netrw_method")? ': netrw_method='.w:netrw_method : ""),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10222 | if exists("w:netrw_method") && (w:netrw_method == 2 || w:netrw_method == 3) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10223 | " call Decho("case ftp:",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10224 | let path= a:path |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10225 | if path =~ '^\a\{3,}://' |
| 10226 | let path= substitute(path,'^\a\{3,}://[^/]\+/','','') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10227 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10228 | sil! NetrwKeepj .,$d _ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10229 | call s:NetrwRemoteFtpCmd(path,"delete ".'"'.a:rmfile.'"') |
| 10230 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10231 | " call Decho("case ssh: g:netrw_rm_cmd<".g:netrw_rm_cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10232 | let netrw_rm_cmd= s:MakeSshCmd(g:netrw_rm_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10233 | " call Decho("netrw_rm_cmd<".netrw_rm_cmd.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10234 | if !exists("b:netrw_curdir") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10235 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"for some reason b:netrw_curdir doesn't exist!",53) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10236 | let ok="q" |
| 10237 | else |
| 10238 | let remotedir= substitute(b:netrw_curdir,'^.*//[^/]\+/\(.*\)$','\1','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10239 | " call Decho("netrw_rm_cmd<".netrw_rm_cmd.">",'~'.expand("<slnum>")) |
| 10240 | " call Decho("remotedir<".remotedir.">",'~'.expand("<slnum>")) |
| 10241 | " call Decho("rmfile<".a:rmfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10242 | if remotedir != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10243 | let netrw_rm_cmd= netrw_rm_cmd." ".s:ShellEscape(fnameescape(remotedir.a:rmfile)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10244 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10245 | let netrw_rm_cmd= netrw_rm_cmd." ".s:ShellEscape(fnameescape(a:rmfile)) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10246 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10247 | " call Decho("call system(".netrw_rm_cmd.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10248 | let ret= system(netrw_rm_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10249 | if v:shell_error != 0 |
| 10250 | if exists("b:netrw_curdir") && b:netrw_curdir != getcwd() && !g:netrw_keepdir |
| 10251 | call netrw#ErrorMsg(s:ERROR,"remove failed; perhaps due to vim's current directory<".getcwd()."> not matching netrw's (".b:netrw_curdir.") (see :help netrw-c)",102) |
| 10252 | else |
| 10253 | call netrw#ErrorMsg(s:WARNING,"cmd<".netrw_rm_cmd."> failed",60) |
| 10254 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10255 | elseif ret != 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10256 | call netrw#ErrorMsg(s:WARNING,"cmd<".netrw_rm_cmd."> failed",60) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10257 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10258 | " call Decho("returned=".ret." errcode=".v:shell_error,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10259 | endif |
| 10260 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10261 | elseif ok =~# 'q\%[uit]' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10262 | " call Decho("ok==".ok,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10263 | endif |
| 10264 | |
| 10265 | else |
| 10266 | " attempt to remove directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10267 | " call Decho("attempt to remove directory",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10268 | if !all |
| 10269 | call inputsave() |
| 10270 | let ok= input("Confirm deletion of directory<".a:rmfile."> ","[{y(es)},n(o),a(ll),q(uit)] ") |
| 10271 | call inputrestore() |
| 10272 | if ok == "" |
| 10273 | let ok="no" |
| 10274 | endif |
| 10275 | let ok= substitute(ok,'\[{y(es)},n(o),a(ll),q(uit)]\s*','','e') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10276 | if ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10277 | let all= 1 |
| 10278 | endif |
| 10279 | endif |
| 10280 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10281 | if all || ok =~# 'y\%[es]' || ok == "" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10282 | if exists("w:netrw_method") && (w:netrw_method == 2 || w:netrw_method == 3) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10283 | NetrwKeepj call s:NetrwRemoteFtpCmd(a:path,"rmdir ".a:rmfile) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10284 | else |
| 10285 | let rmfile = substitute(a:path.a:rmfile,'/$','','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10286 | let netrw_rmdir_cmd = s:MakeSshCmd(netrw#WinPath(g:netrw_rmdir_cmd)).' '.s:ShellEscape(netrw#WinPath(rmfile)) |
| 10287 | " call Decho("attempt to remove dir: system(".netrw_rmdir_cmd.")",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 10288 | let ret= system(netrw_rmdir_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10289 | " call Decho("returned=".ret." errcode=".v:shell_error,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10290 | |
| 10291 | if v:shell_error != 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10292 | " call Decho("v:shell_error not 0",'~'.expand("<slnum>")) |
| 10293 | let netrw_rmf_cmd= s:MakeSshCmd(netrw#WinPath(g:netrw_rmf_cmd)).' '.s:ShellEscape(netrw#WinPath(substitute(rmfile,'[\/]$','','e'))) |
| 10294 | " call Decho("2nd attempt to remove dir: system(".netrw_rmf_cmd.")",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 10295 | let ret= system(netrw_rmf_cmd) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10296 | " call Decho("returned=".ret." errcode=".v:shell_error,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10297 | |
| 10298 | if v:shell_error != 0 && !exists("g:netrw_quiet") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10299 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"unable to remove directory<".rmfile."> -- is it empty?",22) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10300 | endif |
| 10301 | endif |
| 10302 | endif |
| 10303 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10304 | elseif ok =~# 'q\%[uit]' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10305 | " call Decho("ok==".ok,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10306 | endif |
| 10307 | endif |
| 10308 | |
| 10309 | " call Dret("s:NetrwRemoteRmFile ".ok) |
| 10310 | return ok |
| 10311 | endfun |
| 10312 | |
| 10313 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10314 | " s:NetrwRemoteRename: rename a remote file or directory {{{2 |
| 10315 | fun! s:NetrwRemoteRename(usrhost,path) range |
| 10316 | " call Dfunc("NetrwRemoteRename(usrhost<".a:usrhost."> path<".a:path.">)") |
| 10317 | |
| 10318 | " preparation for removing multiple files/directories |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10319 | let svpos = winsaveview() |
| 10320 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10321 | let ctr = a:firstline |
| 10322 | let rename_cmd = s:MakeSshCmd(g:netrw_rename_cmd) |
| 10323 | |
| 10324 | " rename files given by the markfilelist |
| 10325 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
| 10326 | for oldname in s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10327 | " call Decho("oldname<".oldname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10328 | if exists("subfrom") |
| 10329 | let newname= substitute(oldname,subfrom,subto,'') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10330 | " call Decho("subfrom<".subfrom."> subto<".subto."> newname<".newname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10331 | else |
| 10332 | call inputsave() |
| 10333 | let newname= input("Moving ".oldname." to : ",oldname) |
| 10334 | call inputrestore() |
| 10335 | if newname =~ '^s/' |
| 10336 | let subfrom = substitute(newname,'^s/\([^/]*\)/.*/$','\1','') |
| 10337 | let subto = substitute(newname,'^s/[^/]*/\(.*\)/$','\1','') |
| 10338 | let newname = substitute(oldname,subfrom,subto,'') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10339 | " call Decho("subfrom<".subfrom."> subto<".subto."> newname<".newname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10340 | endif |
| 10341 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10342 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10343 | if exists("w:netrw_method") && (w:netrw_method == 2 || w:netrw_method == 3) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10344 | NetrwKeepj call s:NetrwRemoteFtpCmd(a:path,"rename ".oldname." ".newname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10345 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10346 | let oldname= s:ShellEscape(a:path.oldname) |
| 10347 | let newname= s:ShellEscape(a:path.newname) |
| 10348 | " call Decho("system(netrw#WinPath(".rename_cmd.") ".oldname.' '.newname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10349 | let ret = system(netrw#WinPath(rename_cmd).' '.oldname.' '.newname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10350 | endif |
| 10351 | |
| 10352 | endfor |
| 10353 | call s:NetrwUnMarkFile(1) |
| 10354 | |
| 10355 | else |
| 10356 | |
| 10357 | " attempt to rename files/directories |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10358 | let keepsol= &l:sol |
| 10359 | setl nosol |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10360 | while ctr <= a:lastline |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10361 | exe "NetrwKeepj ".ctr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10362 | |
| 10363 | let oldname= s:NetrwGetWord() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10364 | " call Decho("oldname<".oldname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10365 | |
| 10366 | call inputsave() |
| 10367 | let newname= input("Moving ".oldname." to : ",oldname) |
| 10368 | call inputrestore() |
| 10369 | |
| 10370 | if exists("w:netrw_method") && (w:netrw_method == 2 || w:netrw_method == 3) |
| 10371 | call s:NetrwRemoteFtpCmd(a:path,"rename ".oldname." ".newname) |
| 10372 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10373 | let oldname= s:ShellEscape(a:path.oldname) |
| 10374 | let newname= s:ShellEscape(a:path.newname) |
| 10375 | " call Decho("system(netrw#WinPath(".rename_cmd.") ".oldname.' '.newname.")",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10376 | let ret = system(netrw#WinPath(rename_cmd).' '.oldname.' '.newname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10377 | endif |
| 10378 | |
| 10379 | let ctr= ctr + 1 |
| 10380 | endwhile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10381 | let &l:sol= keepsol |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10382 | endif |
| 10383 | |
| 10384 | " refresh the directory |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10385 | NetrwKeepj call s:NetrwRefresh(0,s:NetrwBrowseChgDir(0,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10386 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 10387 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10388 | |
| 10389 | " call Dret("NetrwRemoteRename") |
| 10390 | endfun |
| 10391 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10392 | " ========================================== |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10393 | " Local Directory Browsing Support: {{{1 |
| 10394 | " ========================================== |
| 10395 | |
| 10396 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10397 | " netrw#FileUrlEdit: handles editing file://* files {{{2 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10398 | " Should accept: file://localhost/etc/fstab |
| 10399 | " file:///etc/fstab |
| 10400 | " file:///c:/WINDOWS/clock.avi |
| 10401 | " file:///c|/WINDOWS/clock.avi |
| 10402 | " file://localhost/c:/WINDOWS/clock.avi |
| 10403 | " file://localhost/c|/WINDOWS/clock.avi |
| 10404 | " file://c:/foo.txt |
| 10405 | " file:///c:/foo.txt |
| 10406 | " and %XX (where X is [0-9a-fA-F] is converted into a character with the given hexadecimal value |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10407 | fun! netrw#FileUrlEdit(fname) |
| 10408 | " call Dfunc("netrw#FileUrlEdit(fname<".a:fname.">)") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10409 | let fname = a:fname |
| 10410 | if fname =~ '^file://localhost/' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10411 | " call Decho('converting file://localhost/ -to- file:///','~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10412 | let fname= substitute(fname,'^file://localhost/','file:///','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10413 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10414 | endif |
| 10415 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
| 10416 | if fname =~ '^file:///\=\a[|:]/' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10417 | " call Decho('converting file:///\a|/ -to- file://\a:/','~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10418 | let fname = substitute(fname,'^file:///\=\(\a\)[|:]/','file://\1:/','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10419 | " call Decho("fname<".fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10420 | endif |
| 10421 | endif |
| 10422 | let fname2396 = netrw#RFC2396(fname) |
| 10423 | let fname2396e= fnameescape(fname2396) |
| 10424 | let plainfname= substitute(fname2396,'file://\(.*\)','\1',"") |
| 10425 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10426 | " call Decho("windows exception for plainfname",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10427 | if plainfname =~ '^/\+\a:' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10428 | " call Decho('removing leading "/"s','~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10429 | let plainfname= substitute(plainfname,'^/\+\(\a:\)','\1','') |
| 10430 | endif |
| 10431 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10432 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10433 | " call Decho("fname2396<".fname2396.">",'~'.expand("<slnum>")) |
| 10434 | " call Decho("plainfname<".plainfname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10435 | exe "sil doau BufReadPre ".fname2396e |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10436 | exe 'NetrwKeepj keepalt edit '.plainfname |
| 10437 | exe 'sil! NetrwKeepj keepalt bdelete '.fnameescape(a:fname) |
| 10438 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10439 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10440 | " call Dret("netrw#FileUrlEdit") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10441 | exe "sil doau BufReadPost ".fname2396e |
| 10442 | endfun |
| 10443 | |
| 10444 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10445 | " netrw#LocalBrowseCheck: {{{2 |
| 10446 | fun! netrw#LocalBrowseCheck(dirname) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10447 | " This function is called by netrwPlugin.vim's s:LocalBrowse(), s:NetrwRexplore(), and by <cr> when atop listed file/directory |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10448 | " unfortunate interaction -- split window debugging can't be |
| 10449 | " used here, must use D-echoRemOn or D-echoTabOn -- the BufEnter |
| 10450 | " event triggers another call to LocalBrowseCheck() when attempts |
| 10451 | " to write to the DBG buffer are made. |
| 10452 | " The &ft == "netrw" test was installed because the BufEnter event |
| 10453 | " would hit when re-entering netrw windows, creating unexpected |
| 10454 | " refreshes (and would do so in the middle of NetrwSaveOptions(), too) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10455 | " call Dfunc("netrw#LocalBrowseCheck(dirname<".a:dirname.">") |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10456 | " call Decho("isdir<".a:dirname."> =".isdirectory(s:NetrwFile(a:dirname)).((exists("s:treeforceredraw")? " treeforceredraw" : "")).'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10457 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10458 | " call Dredir("ls!","netrw#LocalBrowseCheck") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10459 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
| 10460 | " call Decho("current buffer#".bufnr("%")."<".bufname("%")."> ft=".&ft,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10461 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10462 | let ykeep= @@ |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10463 | if isdirectory(s:NetrwFile(a:dirname)) |
| 10464 | " call Decho("is-directory ft<".&ft."> b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : " doesn't exist")."> dirname<".a:dirname.">"." line($)=".line("$")." ft<".&ft."> g:netrw_fastbrowse=".g:netrw_fastbrowse,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10465 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10466 | if &ft != "netrw" || (exists("b:netrw_curdir") && b:netrw_curdir != a:dirname) || g:netrw_fastbrowse <= 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10467 | " call Decho("case 1 : ft=".&ft,'~'.expand("<slnum>")) |
| 10468 | " call Decho("s:rexposn_".bufnr("%")."<".bufname("%")."> ".(exists("s:rexposn_".bufnr("%"))? "exists" : "does not exist"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10469 | sil! NetrwKeepj keepalt call s:NetrwBrowse(1,a:dirname) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 10470 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10471 | elseif &ft == "netrw" && line("$") == 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10472 | " call Decho("case 2 (ft≡netrw && line($)≡1)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10473 | sil! NetrwKeepj keepalt call s:NetrwBrowse(1,a:dirname) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 10474 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10475 | elseif exists("s:treeforceredraw") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10476 | " call Decho("case 3 (treeforceredraw)",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10477 | unlet s:treeforceredraw |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10478 | sil! NetrwKeepj keepalt call s:NetrwBrowse(1,a:dirname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10479 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10480 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10481 | " call Dret("netrw#LocalBrowseCheck") |
| 10482 | return |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10483 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 10484 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10485 | " following code wipes out currently unused netrw buffers |
| 10486 | " IF g:netrw_fastbrowse is zero (ie. slow browsing selected) |
| 10487 | " AND IF the listing style is not a tree listing |
| 10488 | if exists("g:netrw_fastbrowse") && g:netrw_fastbrowse == 0 && g:netrw_liststyle != s:TREELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10489 | " call Decho("wiping out currently unused netrw buffers",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10490 | let ibuf = 1 |
| 10491 | let buflast = bufnr("$") |
| 10492 | while ibuf <= buflast |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10493 | if bufwinnr(ibuf) == -1 && isdirectory(s:NetrwFile(bufname(ibuf))) |
| 10494 | exe "sil! keepj keepalt ".ibuf."bw!" |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10495 | endif |
| 10496 | let ibuf= ibuf + 1 |
| 10497 | endwhile |
| 10498 | endif |
| 10499 | let @@= ykeep |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10500 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
| 10501 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10502 | " not a directory, ignore it |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10503 | " call Dret("netrw#LocalBrowseCheck : not a directory, ignoring it; dirname<".a:dirname.">") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10504 | endfun |
| 10505 | |
| 10506 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10507 | " s:LocalBrowseRefresh: this function is called after a user has {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10508 | " performed any shell command. The idea is to cause all local-browsing |
| 10509 | " buffers to be refreshed after a user has executed some shell command, |
| 10510 | " on the chance that s/he removed/created a file/directory with it. |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10511 | fun! s:LocalBrowseRefresh() |
| 10512 | " call Dfunc("s:LocalBrowseRefresh() tabpagenr($)=".tabpagenr("$")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10513 | " call Decho("s:netrw_browselist =".(exists("s:netrw_browselist")? string(s:netrw_browselist) : '<n/a>'),'~'.expand("<slnum>")) |
| 10514 | " call Decho("w:netrw_bannercnt =".(exists("w:netrw_bannercnt")? string(w:netrw_bannercnt) : '<n/a>'),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10515 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10516 | " determine which buffers currently reside in a tab |
| 10517 | if !exists("s:netrw_browselist") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10518 | " call Dret("s:LocalBrowseRefresh : browselist is empty") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10519 | return |
| 10520 | endif |
| 10521 | if !exists("w:netrw_bannercnt") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10522 | " call Dret("s:LocalBrowseRefresh : don't refresh when focus not on netrw window") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10523 | return |
| 10524 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10525 | if exists("s:netrw_events") && s:netrw_events == 1 |
| 10526 | " s:LocalFastBrowser gets called (indirectly) from a |
| 10527 | let s:netrw_events= 2 |
| 10528 | " call Dret("s:LocalBrowseRefresh : avoid initial double refresh") |
| 10529 | return |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 10530 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10531 | let itab = 1 |
| 10532 | let buftablist = [] |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10533 | let ykeep = @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10534 | while itab <= tabpagenr("$") |
| 10535 | let buftablist = buftablist + tabpagebuflist() |
| 10536 | let itab = itab + 1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10537 | sil! tabn |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10538 | endwhile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10539 | " call Decho("buftablist".string(buftablist),'~'.expand("<slnum>")) |
| 10540 | " call Decho("s:netrw_browselist<".(exists("s:netrw_browselist")? string(s:netrw_browselist) : "").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10541 | " GO through all buffers on netrw_browselist (ie. just local-netrw buffers): |
| 10542 | " | refresh any netrw window |
| 10543 | " | wipe out any non-displaying netrw buffer |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10544 | let curwinid = win_getid(winnr()) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10545 | let ibl = 0 |
| 10546 | for ibuf in s:netrw_browselist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10547 | " call Decho("bufwinnr(".ibuf.") index(buftablist,".ibuf.")=".index(buftablist,ibuf),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10548 | if bufwinnr(ibuf) == -1 && index(buftablist,ibuf) == -1 |
| 10549 | " wipe out any non-displaying netrw buffer |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10550 | " (ibuf not shown in a current window AND |
| 10551 | " ibuf not in any tab) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10552 | " call Decho("wiping buf#".ibuf,"<".bufname(ibuf).">",'~'.expand("<slnum>")) |
| 10553 | exe "sil! keepj bd ".fnameescape(ibuf) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10554 | call remove(s:netrw_browselist,ibl) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10555 | " call Decho("browselist=".string(s:netrw_browselist),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10556 | continue |
| 10557 | elseif index(tabpagebuflist(),ibuf) != -1 |
| 10558 | " refresh any netrw buffer |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10559 | " call Decho("refresh buf#".ibuf.'-> win#'.bufwinnr(ibuf),'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10560 | exe bufwinnr(ibuf)."wincmd w" |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10561 | if getline(".") =~# 'Quick Help' |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10562 | " decrement g:netrw_quickhelp to prevent refresh from changing g:netrw_quickhelp |
| 10563 | " (counteracts s:NetrwBrowseChgDir()'s incrementing) |
| 10564 | let g:netrw_quickhelp= g:netrw_quickhelp - 1 |
| 10565 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10566 | " call Decho("#3: quickhelp=".g:netrw_quickhelp,'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10567 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
| 10568 | NetrwKeepj call s:NetrwRefreshTreeDict(w:netrw_treetop) |
| 10569 | endif |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10570 | NetrwKeepj call s:NetrwRefresh(1,s:NetrwBrowseChgDir(1,'./')) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10571 | endif |
| 10572 | let ibl= ibl + 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10573 | " call Decho("bottom of s:netrw_browselist for loop: ibl=".ibl,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10574 | endfor |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 10575 | " call Decho("restore window: win_gotoid(".curwinid.")") |
| 10576 | call win_gotoid(curwinid) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10577 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10578 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10579 | " call Dret("s:LocalBrowseRefresh") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10580 | endfun |
| 10581 | |
| 10582 | " --------------------------------------------------------------------- |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10583 | " s:LocalFastBrowser: handles setting up/taking down fast browsing for the local browser {{{2 |
| 10584 | " |
| 10585 | " g:netrw_ Directory Is |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10586 | " fastbrowse Local Remote |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10587 | " slow 0 D D D=Deleting a buffer implies it will not be re-used (slow) |
| 10588 | " med 1 D H H=Hiding a buffer implies it may be re-used (fast) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10589 | " fast 2 H H |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10590 | " |
| 10591 | " Deleting a buffer means that it will be re-loaded when examined, hence "slow". |
| 10592 | " Hiding a buffer means that it will be re-used when examined, hence "fast". |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10593 | " (re-using a buffer may not be as accurate) |
| 10594 | " |
| 10595 | " s:netrw_events : doesn't exist, s:LocalFastBrowser() will install autocmds whena med or fast browsing |
| 10596 | " =1: autocmds installed, but ignore next FocusGained event to avoid initial double-refresh of listing. |
| 10597 | " BufEnter may be first event, then a FocusGained event. Ignore the first FocusGained event. |
| 10598 | " If :Explore used: it sets s:netrw_events to 2, so no FocusGained events are ignored. |
| 10599 | " =2: autocmds installed (doesn't ignore any FocusGained events) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10600 | fun! s:LocalFastBrowser() |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10601 | " call Dfunc("LocalFastBrowser() g:netrw_fastbrowse=".g:netrw_fastbrowse) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10602 | " call Decho("s:netrw_events ".(exists("s:netrw_events")? "exists" : 'n/a'),'~'.expand("<slnum>")) |
| 10603 | " call Decho("autocmd: ShellCmdPost ".(exists("#ShellCmdPost")? "installed" : "not installed"),'~'.expand("<slnum>")) |
| 10604 | " call Decho("autocmd: FocusGained ".(exists("#FocusGained")? "installed" : "not installed"),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10605 | |
| 10606 | " initialize browselist, a list of buffer numbers that the local browser has used |
| 10607 | if !exists("s:netrw_browselist") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10608 | " call Decho("initialize s:netrw_browselist",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10609 | let s:netrw_browselist= [] |
| 10610 | endif |
| 10611 | |
| 10612 | " append current buffer to fastbrowse list |
| 10613 | if empty(s:netrw_browselist) || bufnr("%") > s:netrw_browselist[-1] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10614 | " call Decho("appendng current buffer to browselist",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10615 | call add(s:netrw_browselist,bufnr("%")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10616 | " call Decho("browselist=".string(s:netrw_browselist),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10617 | endif |
| 10618 | |
| 10619 | " enable autocmd events to handle refreshing/removing local browser buffers |
| 10620 | " If local browse buffer is currently showing: refresh it |
| 10621 | " If local browse buffer is currently hidden : wipe it |
| 10622 | " g:netrw_fastbrowse=0 : slow speed, never re-use directory listing |
| 10623 | " =1 : medium speed, re-use directory listing for remote only |
| 10624 | " =2 : fast speed, always re-use directory listing when possible |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10625 | if g:netrw_fastbrowse <= 1 && !exists("#ShellCmdPost") && !exists("s:netrw_events") |
| 10626 | let s:netrw_events= 1 |
| 10627 | augroup AuNetrwEvent |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10628 | au! |
| 10629 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10630 | " call Decho("installing autocmd: ShellCmdPost",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10631 | au ShellCmdPost * call s:LocalBrowseRefresh() |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10632 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10633 | " call Decho("installing autocmds: ShellCmdPost FocusGained",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10634 | au ShellCmdPost,FocusGained * call s:LocalBrowseRefresh() |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10635 | endif |
| 10636 | augroup END |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10637 | |
| 10638 | " user must have changed fastbrowse to its fast setting, so remove |
| 10639 | " the associated autocmd events |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10640 | elseif g:netrw_fastbrowse > 1 && exists("#ShellCmdPost") && exists("s:netrw_events") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10641 | " call Decho("remove AuNetrwEvent autcmd group",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10642 | unlet s:netrw_events |
| 10643 | augroup AuNetrwEvent |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10644 | au! |
| 10645 | augroup END |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10646 | augroup! AuNetrwEvent |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10647 | endif |
| 10648 | |
| 10649 | " call Dret("LocalFastBrowser : browselist<".string(s:netrw_browselist).">") |
| 10650 | endfun |
| 10651 | |
| 10652 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10653 | " s:LocalListing: does the job of "ls" for local directories {{{2 |
| 10654 | fun! s:LocalListing() |
| 10655 | " call Dfunc("s:LocalListing()") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10656 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
| 10657 | " call Decho("modified=".&modified." modifiable=".&modifiable." readonly=".&readonly,'~'.expand("<slnum>")) |
| 10658 | " call Decho("tab#".tabpagenr()." win#".winnr()." buf#".bufnr("%")."<".bufname("%")."> line#".line(".")." col#".col(".")." winline#".winline()." wincol#".wincol(),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10659 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10660 | " if exists("b:netrw_curdir") |call Decho('b:netrw_curdir<'.b:netrw_curdir.">") |else|call Decho("b:netrw_curdir doesn't exist",'~'.expand("<slnum>")) |endif |
| 10661 | " if exists("g:netrw_sort_by")|call Decho('g:netrw_sort_by<'.g:netrw_sort_by.">")|else|call Decho("g:netrw_sort_by doesn't exist",'~'.expand("<slnum>"))|endif |
| 10662 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10663 | |
| 10664 | " get the list of files contained in the current directory |
| 10665 | let dirname = b:netrw_curdir |
| 10666 | let dirnamelen = strlen(b:netrw_curdir) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10667 | let filelist = s:NetrwGlob(dirname,"*",0) |
| 10668 | let filelist = filelist + s:NetrwGlob(dirname,".*",0) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10669 | " call Decho("filelist=".string(filelist),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10670 | |
| 10671 | if g:netrw_cygwin == 0 && (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10672 | " call Decho("filelist=".string(filelist),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10673 | elseif index(filelist,'..') == -1 && b:netrw_curdir !~ '/' |
| 10674 | " include ../ in the glob() entry if its missing |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10675 | " call Decho("forcibly including on \"..\"",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10676 | let filelist= filelist+[s:ComposePath(b:netrw_curdir,"../")] |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10677 | " call Decho("filelist=".string(filelist),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10678 | endif |
| 10679 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10680 | " call Decho("before while: dirname <".dirname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10681 | " call Decho("before while: dirnamelen<".dirnamelen.">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10682 | " call Decho("before while: filelist =".string(filelist),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10683 | |
| 10684 | if get(g:, 'netrw_dynamic_maxfilenamelen', 0) |
| 10685 | let filelistcopy = map(deepcopy(filelist),'fnamemodify(v:val, ":t")') |
| 10686 | let g:netrw_maxfilenamelen = max(map(filelistcopy,'len(v:val)')) + 1 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10687 | " call Decho("dynamic_maxfilenamelen: filenames =".string(filelistcopy),'~'.expand("<slnum>")) |
| 10688 | " call Decho("dynamic_maxfilenamelen: g:netrw_maxfilenamelen=".g:netrw_maxfilenamelen,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10689 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10690 | " call Decho("g:netrw_banner=".g:netrw_banner.": banner ".(g:netrw_banner? "enabled" : "suppressed").": (line($)=".line("$")." byte2line(1)=".byte2line(1)." bannercnt=".w:netrw_bannercnt.")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10691 | |
| 10692 | for filename in filelist |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10693 | " call Decho(" ",'~'.expand("<slnum>")) |
| 10694 | " call Decho("for filename in filelist: filename<".filename.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10695 | |
| 10696 | if getftype(filename) == "link" |
| 10697 | " indicate a symbolic link |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10698 | " call Decho("indicate <".filename."> is a symbolic link with trailing @",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10699 | let pfile= filename."@" |
| 10700 | |
| 10701 | elseif getftype(filename) == "socket" |
| 10702 | " indicate a socket |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10703 | " call Decho("indicate <".filename."> is a socket with trailing =",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10704 | let pfile= filename."=" |
| 10705 | |
| 10706 | elseif getftype(filename) == "fifo" |
| 10707 | " indicate a fifo |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10708 | " call Decho("indicate <".filename."> is a fifo with trailing |",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10709 | let pfile= filename."|" |
| 10710 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10711 | elseif isdirectory(s:NetrwFile(filename)) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10712 | " indicate a directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10713 | " call Decho("indicate <".filename."> is a directory with trailing /",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10714 | let pfile= filename."/" |
| 10715 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10716 | elseif exists("b:netrw_curdir") && b:netrw_curdir !~ '^.*://' && !isdirectory(s:NetrwFile(filename)) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10717 | if (has("win32") || has("win95") || has("win64") || has("win16")) |
| 10718 | if filename =~ '\.[eE][xX][eE]$' || filename =~ '\.[cC][oO][mM]$' || filename =~ '\.[bB][aA][tT]$' |
| 10719 | " indicate an executable |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10720 | " call Decho("indicate <".filename."> is executable with trailing *",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10721 | let pfile= filename."*" |
| 10722 | else |
| 10723 | " normal file |
| 10724 | let pfile= filename |
| 10725 | endif |
| 10726 | elseif executable(filename) |
| 10727 | " indicate an executable |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10728 | " call Decho("indicate <".filename."> is executable with trailing *",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10729 | let pfile= filename."*" |
| 10730 | else |
| 10731 | " normal file |
| 10732 | let pfile= filename |
| 10733 | endif |
| 10734 | |
| 10735 | else |
| 10736 | " normal file |
| 10737 | let pfile= filename |
| 10738 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10739 | " call Decho("pfile<".pfile."> (after *@/ appending)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10740 | |
| 10741 | if pfile =~ '//$' |
| 10742 | let pfile= substitute(pfile,'//$','/','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10743 | " call Decho("change // to /: pfile<".pfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10744 | endif |
| 10745 | let pfile= strpart(pfile,dirnamelen) |
| 10746 | let pfile= substitute(pfile,'^[/\\]','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10747 | " call Decho("filename<".filename.">",'~'.expand("<slnum>")) |
| 10748 | " call Decho("pfile <".pfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10749 | |
| 10750 | if w:netrw_liststyle == s:LONGLIST |
| 10751 | let sz = getfsize(filename) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10752 | if g:netrw_sizestyle =~# "[hH]" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10753 | let sz= s:NetrwHumanReadable(sz) |
| 10754 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10755 | let fsz = strpart(" ",1,15-strlen(sz)).sz |
| 10756 | let pfile= pfile."\t".fsz." ".strftime(g:netrw_timefmt,getftime(filename)) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10757 | " call Decho("longlist support: sz=".sz." fsz=".fsz,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10758 | endif |
| 10759 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10760 | if g:netrw_sort_by =~# "^t" |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10761 | " sort by time (handles time up to 1 quintillion seconds, US) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10762 | " call Decho("getftime(".filename.")=".getftime(filename),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10763 | let t = getftime(filename) |
| 10764 | let ft = strpart("000000000000000000",1,18-strlen(t)).t |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10765 | " call Decho("exe NetrwKeepj put ='".ft.'/'.filename."'",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10766 | let ftpfile= ft.'/'.pfile |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10767 | sil! NetrwKeepj put=ftpfile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10768 | |
| 10769 | elseif g:netrw_sort_by =~ "^s" |
| 10770 | " sort by size (handles file sizes up to 1 quintillion bytes, US) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10771 | " call Decho("getfsize(".filename.")=".getfsize(filename),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10772 | let sz = getfsize(filename) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10773 | if g:netrw_sizestyle =~# "[hH]" |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10774 | let sz= s:NetrwHumanReadable(sz) |
| 10775 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10776 | let fsz = strpart("000000000000000000",1,18-strlen(sz)).sz |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10777 | " call Decho("exe NetrwKeepj put ='".fsz.'/'.filename."'",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10778 | let fszpfile= fsz.'/'.pfile |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10779 | sil! NetrwKeepj put =fszpfile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10780 | |
| 10781 | else |
| 10782 | " sort by name |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10783 | " call Decho("exe NetrwKeepj put ='".pfile."'",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10784 | sil! NetrwKeepj put=pfile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10785 | endif |
| 10786 | endfor |
| 10787 | |
| 10788 | " cleanup any windows mess at end-of-line |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10789 | sil! NetrwKeepj g/^$/d |
| 10790 | sil! NetrwKeepj %s/\r$//e |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10791 | call histdel("/",-1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10792 | " call Decho("exe setl ts=".(g:netrw_maxfilenamelen+1),'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 10793 | exe "setl ts=".(g:netrw_maxfilenamelen+1) |
| 10794 | |
| 10795 | " call Dret("s:LocalListing") |
| 10796 | endfun |
| 10797 | |
| 10798 | " --------------------------------------------------------------------- |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10799 | " s:NetrwLocalExecute: uses system() to execute command under cursor ("X" command support) {{{2 |
| 10800 | fun! s:NetrwLocalExecute(cmd) |
| 10801 | " call Dfunc("s:NetrwLocalExecute(cmd<".a:cmd.">)") |
| 10802 | let ykeep= @@ |
| 10803 | " sanity check |
| 10804 | if !executable(a:cmd) |
| 10805 | call netrw#ErrorMsg(s:ERROR,"the file<".a:cmd."> is not executable!",89) |
| 10806 | let @@= ykeep |
| 10807 | " call Dret("s:NetrwLocalExecute") |
| 10808 | return |
| 10809 | endif |
| 10810 | |
| 10811 | let optargs= input(":!".a:cmd,"","file") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10812 | " call Decho("optargs<".optargs.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10813 | let result= system(a:cmd.optargs) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10814 | " call Decho("result,'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10815 | |
| 10816 | " strip any ansi escape sequences off |
| 10817 | let result = substitute(result,"\e\\[[0-9;]*m","","g") |
| 10818 | |
| 10819 | " show user the result(s) |
| 10820 | echomsg result |
| 10821 | let @@= ykeep |
| 10822 | |
| 10823 | " call Dret("s:NetrwLocalExecute") |
| 10824 | endfun |
| 10825 | |
| 10826 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10827 | " s:NetrwLocalRename: rename a local file or directory {{{2 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10828 | fun! s:NetrwLocalRename(path) range |
| 10829 | " call Dfunc("NetrwLocalRename(path<".a:path.">)") |
| 10830 | |
| 10831 | " preparation for removing multiple files/directories |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10832 | let ykeep = @@ |
| 10833 | let ctr = a:firstline |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10834 | let svpos = winsaveview() |
| 10835 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10836 | |
| 10837 | " rename files given by the markfilelist |
| 10838 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
| 10839 | for oldname in s:netrwmarkfilelist_{bufnr("%")} |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10840 | " call Decho("oldname<".oldname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10841 | if exists("subfrom") |
| 10842 | let newname= substitute(oldname,subfrom,subto,'') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10843 | " call Decho("subfrom<".subfrom."> subto<".subto."> newname<".newname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10844 | else |
| 10845 | call inputsave() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10846 | let newname= input("Moving ".oldname." to : ",oldname,"file") |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10847 | call inputrestore() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10848 | if newname =~ '' |
| 10849 | " two ctrl-x's : ignore all of string preceding the ctrl-x's |
| 10850 | let newname = substitute(newname,'^.*','','') |
| 10851 | elseif newname =~ '' |
| 10852 | " one ctrl-x : ignore portion of string preceding ctrl-x but after last / |
| 10853 | let newname = substitute(newname,'[^/]*','','') |
| 10854 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10855 | if newname =~ '^s/' |
| 10856 | let subfrom = substitute(newname,'^s/\([^/]*\)/.*/$','\1','') |
| 10857 | let subto = substitute(newname,'^s/[^/]*/\(.*\)/$','\1','') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10858 | " call Decho("subfrom<".subfrom."> subto<".subto."> newname<".newname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10859 | let newname = substitute(oldname,subfrom,subto,'') |
| 10860 | endif |
| 10861 | endif |
| 10862 | call rename(oldname,newname) |
| 10863 | endfor |
| 10864 | call s:NetrwUnmarkList(bufnr("%"),b:netrw_curdir) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10865 | |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10866 | else |
| 10867 | |
| 10868 | " attempt to rename files/directories |
| 10869 | while ctr <= a:lastline |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10870 | exe "NetrwKeepj ".ctr |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10871 | |
| 10872 | " sanity checks |
| 10873 | if line(".") < w:netrw_bannercnt |
| 10874 | let ctr= ctr + 1 |
| 10875 | continue |
| 10876 | endif |
| 10877 | let curword= s:NetrwGetWord() |
| 10878 | if curword == "./" || curword == "../" |
| 10879 | let ctr= ctr + 1 |
| 10880 | continue |
| 10881 | endif |
| 10882 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10883 | NetrwKeepj norm! 0 |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10884 | let oldname= s:ComposePath(a:path,curword) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10885 | " call Decho("oldname<".oldname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10886 | |
| 10887 | call inputsave() |
| 10888 | let newname= input("Moving ".oldname." to : ",substitute(oldname,'/*$','','e')) |
| 10889 | call inputrestore() |
| 10890 | |
| 10891 | call rename(oldname,newname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10892 | " call Decho("renaming <".oldname."> to <".newname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10893 | |
| 10894 | let ctr= ctr + 1 |
| 10895 | endwhile |
| 10896 | endif |
| 10897 | |
| 10898 | " refresh the directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10899 | " call Decho("refresh the directory listing",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10900 | NetrwKeepj call s:NetrwRefresh(1,s:NetrwBrowseChgDir(1,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10901 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 10902 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10903 | let @@= ykeep |
| 10904 | |
| 10905 | " call Dret("NetrwLocalRename") |
| 10906 | endfun |
| 10907 | |
| 10908 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10909 | " s:NetrwLocalRm: {{{2 |
| 10910 | fun! s:NetrwLocalRm(path) range |
| 10911 | " call Dfunc("s:NetrwLocalRm(path<".a:path.">)") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10912 | " call Decho("firstline=".a:firstline." lastline=".a:lastline,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10913 | |
| 10914 | " preparation for removing multiple files/directories |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10915 | let ykeep = @@ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10916 | let ret = 0 |
| 10917 | let all = 0 |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10918 | let svpos = winsaveview() |
| 10919 | " call Decho("saving posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10920 | |
| 10921 | if exists("s:netrwmarkfilelist_{bufnr('%')}") |
| 10922 | " remove all marked files |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10923 | " call Decho("remove all marked files",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10924 | for fname in s:netrwmarkfilelist_{bufnr("%")} |
| 10925 | let ok= s:NetrwLocalRmFile(a:path,fname,all) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10926 | if ok =~# 'q\%[uit]' || ok == "no" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10927 | break |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10928 | elseif ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10929 | let all= 1 |
| 10930 | endif |
| 10931 | endfor |
| 10932 | call s:NetrwUnMarkFile(1) |
| 10933 | |
| 10934 | else |
| 10935 | " remove (multiple) files and directories |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10936 | " call Decho("remove files in range [".a:firstline.",".a:lastline."]",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10937 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10938 | let keepsol= &l:sol |
| 10939 | setl nosol |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10940 | let ctr = a:firstline |
| 10941 | while ctr <= a:lastline |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10942 | exe "NetrwKeepj ".ctr |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10943 | |
| 10944 | " sanity checks |
| 10945 | if line(".") < w:netrw_bannercnt |
| 10946 | let ctr= ctr + 1 |
| 10947 | continue |
| 10948 | endif |
| 10949 | let curword= s:NetrwGetWord() |
| 10950 | if curword == "./" || curword == "../" |
| 10951 | let ctr= ctr + 1 |
| 10952 | continue |
| 10953 | endif |
| 10954 | let ok= s:NetrwLocalRmFile(a:path,curword,all) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10955 | if ok =~# 'q\%[uit]' || ok == "no" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10956 | break |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 10957 | elseif ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10958 | let all= 1 |
| 10959 | endif |
| 10960 | let ctr= ctr + 1 |
| 10961 | endwhile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10962 | let &l:sol= keepsol |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10963 | endif |
| 10964 | |
| 10965 | " refresh the directory |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10966 | " call Decho("bufname<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10967 | if bufname("%") != "NetrwMessage" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10968 | NetrwKeepj call s:NetrwRefresh(1,s:NetrwBrowseChgDir(1,'./')) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 10969 | " call Decho("restoring posn to svpos<".string(svpos).">",'~'.expand("<slnum>")) |
| 10970 | NetrwKeepj call winrestview(svpos) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10971 | endif |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 10972 | let @@= ykeep |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10973 | |
| 10974 | " call Dret("s:NetrwLocalRm") |
| 10975 | endfun |
| 10976 | |
| 10977 | " --------------------------------------------------------------------- |
| 10978 | " s:NetrwLocalRmFile: remove file fname given the path {{{2 |
| 10979 | " Give confirmation prompt unless all==1 |
| 10980 | fun! s:NetrwLocalRmFile(path,fname,all) |
| 10981 | " call Dfunc("s:NetrwLocalRmFile(path<".a:path."> fname<".a:fname."> all=".a:all) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10982 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10983 | let all= a:all |
| 10984 | let ok = "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 10985 | NetrwKeepj norm! 0 |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10986 | let rmfile= s:NetrwFile(s:ComposePath(a:path,a:fname)) |
| 10987 | " call Decho("rmfile<".rmfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10988 | |
| 10989 | if rmfile !~ '^"' && (rmfile =~ '@$' || rmfile !~ '[\/]$') |
| 10990 | " attempt to remove file |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 10991 | " call Decho("attempt to remove file<".rmfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 10992 | if !all |
| 10993 | echohl Statement |
| 10994 | call inputsave() |
| 10995 | let ok= input("Confirm deletion of file<".rmfile."> ","[{y(es)},n(o),a(ll),q(uit)] ") |
| 10996 | call inputrestore() |
| 10997 | echohl NONE |
| 10998 | if ok == "" |
| 10999 | let ok="no" |
| 11000 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11001 | " call Decho("response: ok<".ok.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11002 | let ok= substitute(ok,'\[{y(es)},n(o),a(ll),q(uit)]\s*','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11003 | " call Decho("response: ok<".ok."> (after sub)",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11004 | if ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11005 | let all= 1 |
| 11006 | endif |
| 11007 | endif |
| 11008 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11009 | if all || ok =~# 'y\%[es]' || ok == "" |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11010 | let ret= s:NetrwDelete(rmfile) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11011 | " call Decho("errcode=".v:shell_error." ret=".ret,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11012 | endif |
| 11013 | |
| 11014 | else |
| 11015 | " attempt to remove directory |
| 11016 | if !all |
| 11017 | echohl Statement |
| 11018 | call inputsave() |
| 11019 | let ok= input("Confirm deletion of directory<".rmfile."> ","[{y(es)},n(o),a(ll),q(uit)] ") |
| 11020 | call inputrestore() |
| 11021 | let ok= substitute(ok,'\[{y(es)},n(o),a(ll),q(uit)]\s*','','e') |
| 11022 | if ok == "" |
| 11023 | let ok="no" |
| 11024 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11025 | if ok =~# 'a\%[ll]' |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11026 | let all= 1 |
| 11027 | endif |
| 11028 | endif |
| 11029 | let rmfile= substitute(rmfile,'[\/]$','','e') |
| 11030 | |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11031 | if all || ok =~# 'y\%[es]' || ok == "" |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11032 | if v:version < 704 || (v:version == 704 && !has("patch1107")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11033 | " " call Decho("1st attempt: system(netrw#WinPath(".g:netrw_localrmdir.') '.s:ShellEscape(rmfile).')','~'.expand("<slnum>")) |
| 11034 | call system(netrw#WinPath(g:netrw_localrmdir).' '.s:ShellEscape(rmfile)) |
| 11035 | " " call Decho("v:shell_error=".v:shell_error,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11036 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11037 | if v:shell_error != 0 |
| 11038 | " " call Decho("2nd attempt to remove directory<".rmfile.">",'~'.expand("<slnum>")) |
| 11039 | let errcode= s:NetrwDelete(rmfile) |
| 11040 | " " call Decho("errcode=".errcode,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11041 | |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11042 | if errcode != 0 |
| 11043 | if has("unix") |
| 11044 | " " call Decho("3rd attempt to remove directory<".rmfile.">",'~'.expand("<slnum>")) |
| 11045 | call system("rm ".s:ShellEscape(rmfile)) |
| 11046 | if v:shell_error != 0 && !exists("g:netrw_quiet") |
| 11047 | call netrw#ErrorMsg(s:ERROR,"unable to remove directory<".rmfile."> -- is it empty?",34) |
| 11048 | let ok="no" |
| 11049 | endif |
| 11050 | elseif !exists("g:netrw_quiet") |
| 11051 | call netrw#ErrorMsg(s:ERROR,"unable to remove directory<".rmfile."> -- is it empty?",35) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11052 | let ok="no" |
| 11053 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11054 | endif |
| 11055 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11056 | else |
| 11057 | if delete(rmfile,"d") |
| 11058 | call netrw#ErrorMsg(s:ERROR,"unable to delete directory <".rmfile.">!",103) |
| 11059 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11060 | endif |
| 11061 | endif |
| 11062 | endif |
| 11063 | |
| 11064 | " call Dret("s:NetrwLocalRmFile ".ok) |
| 11065 | return ok |
| 11066 | endfun |
| 11067 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11068 | " ===================================================================== |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11069 | " Support Functions: {{{1 |
| 11070 | |
Bram Moolenaar | 488c651 | 2005-08-11 20:09:58 +0000 | [diff] [blame] | 11071 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11072 | " netrw#Access: intended to provide access to variable values for netrw's test suite {{{2 |
| 11073 | " 0: marked file list of current buffer |
| 11074 | " 1: marked file target |
| 11075 | fun! netrw#Access(ilist) |
| 11076 | if a:ilist == 0 |
| 11077 | if exists("s:netrwmarkfilelist_".bufnr('%')) |
| 11078 | return s:netrwmarkfilelist_{bufnr('%')} |
| 11079 | else |
| 11080 | return "no-list-buf#".bufnr('%') |
| 11081 | endif |
| 11082 | elseif a:ilist == 1 |
| 11083 | return s:netrwmftgt |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11084 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11085 | endfun |
| 11086 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11087 | " --------------------------------------------------------------------- |
| 11088 | " netrw#Call: allows user-specified mappings to call internal netrw functions {{{2 |
| 11089 | fun! netrw#Call(funcname,...) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11090 | return call("s:".a:funcname,a:000) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11091 | endfun |
| 11092 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11093 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11094 | " netrw#Expose: allows UserMaps and pchk to look at otherwise script-local variables {{{2 |
| 11095 | " I expect this function to be used in |
| 11096 | " :PChkAssert netrw#Expose("netrwmarkfilelist") |
| 11097 | " for example. |
| 11098 | fun! netrw#Expose(varname) |
| 11099 | " call Dfunc("netrw#Expose(varname<".a:varname.">)") |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11100 | if exists("s:".a:varname) |
| 11101 | exe "let retval= s:".a:varname |
| 11102 | if exists("g:netrw_pchk") |
| 11103 | if type(retval) == 3 |
| 11104 | let retval = copy(retval) |
| 11105 | let i = 0 |
| 11106 | while i < len(retval) |
| 11107 | let retval[i]= substitute(retval[i],expand("$HOME"),'~','') |
| 11108 | let i = i + 1 |
| 11109 | endwhile |
| 11110 | endif |
| 11111 | " call Dret("netrw#Expose ".string(retval)) |
| 11112 | return string(retval) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11113 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11114 | else |
| 11115 | let retval= "n/a" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11116 | endif |
| 11117 | |
| 11118 | " call Dret("netrw#Expose ".string(retval)) |
| 11119 | return retval |
| 11120 | endfun |
| 11121 | |
| 11122 | " --------------------------------------------------------------------- |
| 11123 | " netrw#Modify: allows UserMaps to set (modify) script-local variables {{{2 |
| 11124 | fun! netrw#Modify(varname,newvalue) |
| 11125 | " call Dfunc("netrw#Modify(varname<".a:varname.">,newvalue<".string(a:newvalue).">)") |
| 11126 | exe "let s:".a:varname."= ".string(a:newvalue) |
| 11127 | " call Dret("netrw#Modify") |
| 11128 | endfun |
| 11129 | |
| 11130 | " --------------------------------------------------------------------- |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11131 | " netrw#RFC2396: converts %xx into characters {{{2 |
| 11132 | fun! netrw#RFC2396(fname) |
| 11133 | " call Dfunc("netrw#RFC2396(fname<".a:fname.">)") |
| 11134 | let fname = escape(substitute(a:fname,'%\(\x\x\)','\=nr2char("0x".submatch(1))','ge')," \t") |
| 11135 | " call Dret("netrw#RFC2396 ".fname) |
| 11136 | return fname |
| 11137 | endfun |
| 11138 | |
| 11139 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11140 | " netrw#UserMaps: supports user-specified maps {{{2 |
| 11141 | " see :help function() |
| 11142 | " |
| 11143 | " g:Netrw_UserMaps is a List with members such as: |
| 11144 | " [[keymap sequence, function reference],...] |
| 11145 | " |
| 11146 | " The referenced function may return a string, |
| 11147 | " refresh : refresh the display |
| 11148 | " -other- : this string will be executed |
| 11149 | " or it may return a List of strings. |
| 11150 | " |
| 11151 | " Each keymap-sequence will be set up with a nnoremap |
| 11152 | " to invoke netrw#UserMaps(islocal). |
| 11153 | " Related functions: |
| 11154 | " netrw#Expose(varname) -- see s:varname variables |
| 11155 | " netrw#Modify(varname,newvalue) -- modify value of s:varname variable |
| 11156 | " netrw#Call(funcname,...) -- call internal netrw function with optional arguments |
| 11157 | fun! netrw#UserMaps(islocal) |
| 11158 | " call Dfunc("netrw#UserMaps(islocal=".a:islocal.")") |
| 11159 | " call Decho("g:Netrw_UserMaps ".(exists("g:Netrw_UserMaps")? "exists" : "does NOT exist"),'~'.expand("<slnum>")) |
| 11160 | |
| 11161 | " set up usermaplist |
| 11162 | if exists("g:Netrw_UserMaps") && type(g:Netrw_UserMaps) == 3 |
| 11163 | " call Decho("g:Netrw_UserMaps has type 3<List>",'~'.expand("<slnum>")) |
| 11164 | for umap in g:Netrw_UserMaps |
| 11165 | " call Decho("type(umap[0]<".string(umap[0]).">)=".type(umap[0])." (should be 1=string)",'~'.expand("<slnum>")) |
| 11166 | " call Decho("type(umap[1])=".type(umap[1])." (should be 1=string)",'~'.expand("<slnum>")) |
| 11167 | " if umap[0] is a string and umap[1] is a string holding a function name |
| 11168 | if type(umap[0]) == 1 && type(umap[1]) == 1 |
| 11169 | " call Decho("nno <buffer> <silent> ".umap[0]." :call s:UserMaps(".a:islocal.",".string(umap[1]).")<cr>",'~'.expand("<slnum>")) |
| 11170 | exe "nno <buffer> <silent> ".umap[0]." :call <SID>UserMaps(".a:islocal.",'".umap[1]."')<cr>" |
| 11171 | else |
| 11172 | call netrw#ErrorMsg(s:WARNING,"ignoring usermap <".string(umap[0])."> -- not a [string,funcref] entry",99) |
| 11173 | endif |
| 11174 | endfor |
| 11175 | endif |
| 11176 | " call Dret("netrw#UserMaps") |
| 11177 | endfun |
| 11178 | |
| 11179 | " --------------------------------------------------------------------- |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 11180 | " netrw#WinPath: tries to insure that the path is windows-acceptable, whether cygwin is used or not {{{2 |
| 11181 | fun! netrw#WinPath(path) |
| 11182 | " call Dfunc("netrw#WinPath(path<".a:path.">)") |
| 11183 | if (!g:netrw_cygwin || &shell !~ '\%(\<bash\>\|\<zsh\>\)\%(\.exe\)\=$') && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 11184 | " remove cygdrive prefix, if present |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11185 | let path = substitute(a:path,g:netrw_cygdrive.'/\(.\)','\1:','') |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 11186 | " remove trailing slash (Win95) |
| 11187 | let path = substitute(path, '\(\\\|/\)$', '', 'g') |
| 11188 | " remove escaped spaces |
| 11189 | let path = substitute(path, '\ ', ' ', 'g') |
| 11190 | " convert slashes to backslashes |
| 11191 | let path = substitute(path, '/', '\', 'g') |
| 11192 | else |
| 11193 | let path= a:path |
| 11194 | endif |
| 11195 | " call Dret("netrw#WinPath <".path.">") |
| 11196 | return path |
| 11197 | endfun |
| 11198 | |
| 11199 | " --------------------------------------------------------------------- |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11200 | " s:NetrwBadd: adds marked files to buffer list or vice versa {{{2 |
| 11201 | " cb : bl2mf=0 add marked files to buffer list |
| 11202 | " cB : bl2mf=1 use bufferlist to mark files |
| 11203 | " (mnemonic: cb = copy (marked files) to buffer list) |
| 11204 | fun! s:NetrwBadd(islocal,bl2mf) |
| 11205 | " " call Dfunc("s:NetrwBadd(islocal=".a:islocal." mf2bl=".mf2bl.")") |
| 11206 | if a:bl2mf |
| 11207 | " cB: add buffer list to marked files |
| 11208 | redir => bufl |
| 11209 | ls |
| 11210 | redir END |
| 11211 | let bufl = map(split(bufl,"\n"),'substitute(v:val,''^.\{-}"\(.*\)".\{-}$'',''\1'','''')') |
| 11212 | for fname in bufl |
| 11213 | call s:NetrwMarkFile(a:islocal,fname) |
| 11214 | endfor |
| 11215 | else |
| 11216 | " cb: add marked files to buffer list |
| 11217 | for fname in s:netrwmarkfilelist_{bufnr("%")} |
| 11218 | " " call Decho("badd ".fname,'~'.expand("<slnum>")) |
| 11219 | exe "badd ".fnameescape(fname) |
| 11220 | endfor |
| 11221 | let curbufnr = bufnr("%") |
| 11222 | let curdir = s:NetrwGetCurdir(a:islocal) |
| 11223 | call s:NetrwUnmarkList(curbufnr,curdir) " remove markings from local buffer |
| 11224 | endif |
| 11225 | " call Dret("s:NetrwBadd") |
| 11226 | endfun |
| 11227 | |
| 11228 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11229 | " s:ComposePath: Appends a new part to a path taking different systems into consideration {{{2 |
| 11230 | fun! s:ComposePath(base,subdir) |
| 11231 | " call Dfunc("s:ComposePath(base<".a:base."> subdir<".a:subdir.">)") |
| 11232 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11233 | if has("amiga") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11234 | " call Decho("amiga",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11235 | let ec = a:base[s:Strlen(a:base)-1] |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11236 | if ec != '/' && ec != ':' |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11237 | let ret = a:base."/" . a:subdir |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11238 | else |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11239 | let ret = a:base.a:subdir |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11240 | endif |
| 11241 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11242 | " COMBAK: test on windows with changing to root directory: :e C:/ |
| 11243 | elseif a:subdir =~ '^\a:[/\\]\([^/\\]\|$\)' && (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11244 | " call Decho("windows",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11245 | let ret= a:subdir |
| 11246 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11247 | elseif a:base =~ '^\a:[/\\]\([^/\\]\|$\)' && (has("win32") || has("win95") || has("win64") || has("win16")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11248 | " call Decho("windows",'~'.expand("<slnum>")) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11249 | if a:base =~ '[/\\]$' |
| 11250 | let ret= a:base.a:subdir |
| 11251 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11252 | let ret= a:base.'/'.a:subdir |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11253 | endif |
| 11254 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11255 | elseif a:base =~ '^\a\{3,}://' |
| 11256 | " call Decho("remote linux/macos",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11257 | let urlbase = substitute(a:base,'^\(\a\+://.\{-}/\)\(.*\)$','\1','') |
| 11258 | let curpath = substitute(a:base,'^\(\a\+://.\{-}/\)\(.*\)$','\2','') |
| 11259 | if a:subdir == '../' |
| 11260 | if curpath =~ '[^/]/[^/]\+/$' |
| 11261 | let curpath= substitute(curpath,'[^/]\+/$','','') |
| 11262 | else |
| 11263 | let curpath="" |
| 11264 | endif |
| 11265 | let ret= urlbase.curpath |
| 11266 | else |
| 11267 | let ret= urlbase.curpath.a:subdir |
| 11268 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11269 | " call Decho("urlbase<".urlbase.">",'~'.expand("<slnum>")) |
| 11270 | " call Decho("curpath<".curpath.">",'~'.expand("<slnum>")) |
| 11271 | " call Decho("ret<".ret.">",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11272 | |
| 11273 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11274 | " call Decho("local linux/macos",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11275 | let ret = substitute(a:base."/".a:subdir,"//","/","g") |
| 11276 | if a:base =~ '^//' |
| 11277 | " keeping initial '//' for the benefit of network share listing support |
| 11278 | let ret= '/'.ret |
| 11279 | endif |
| 11280 | let ret= simplify(ret) |
| 11281 | endif |
| 11282 | |
| 11283 | " call Dret("s:ComposePath ".ret) |
| 11284 | return ret |
| 11285 | endfun |
| 11286 | |
| 11287 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11288 | " s:DeleteBookmark: deletes a file/directory from Netrw's bookmark system {{{2 |
| 11289 | " Related Functions: s:MakeBookmark() s:NetrwBookHistHandler() s:NetrwBookmark() |
| 11290 | fun! s:DeleteBookmark(fname) |
| 11291 | " call Dfunc("s:DeleteBookmark(fname<".a:fname.">)") |
| 11292 | call s:MergeBookmarks() |
| 11293 | |
| 11294 | if exists("g:netrw_bookmarklist") |
| 11295 | let indx= index(g:netrw_bookmarklist,a:fname) |
| 11296 | if indx == -1 |
| 11297 | let indx= 0 |
| 11298 | while indx < len(g:netrw_bookmarklist) |
| 11299 | if g:netrw_bookmarklist[indx] =~ a:fname |
| 11300 | call remove(g:netrw_bookmarklist,indx) |
| 11301 | let indx= indx - 1 |
| 11302 | endif |
| 11303 | let indx= indx + 1 |
| 11304 | endwhile |
| 11305 | else |
| 11306 | " remove exact match |
| 11307 | call remove(g:netrw_bookmarklist,indx) |
| 11308 | endif |
| 11309 | endif |
| 11310 | |
| 11311 | " call Dret("s:DeleteBookmark") |
| 11312 | endfun |
| 11313 | |
| 11314 | " --------------------------------------------------------------------- |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11315 | " s:FileReadable: o/s independent filereadable {{{2 |
| 11316 | fun! s:FileReadable(fname) |
| 11317 | " call Dfunc("s:FileReadable(fname<".a:fname.">)") |
| 11318 | |
| 11319 | if g:netrw_cygwin |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11320 | let ret= filereadable(s:NetrwFile(substitute(a:fname,g:netrw_cygdrive.'/\(.\)','\1:/',''))) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11321 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11322 | let ret= filereadable(s:NetrwFile(a:fname)) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11323 | endif |
| 11324 | |
| 11325 | " call Dret("s:FileReadable ".ret) |
| 11326 | return ret |
| 11327 | endfun |
| 11328 | |
| 11329 | " --------------------------------------------------------------------- |
| 11330 | " s:GetTempfile: gets a tempname that'll work for various o/s's {{{2 |
| 11331 | " Places correct suffix on end of temporary filename, |
| 11332 | " using the suffix provided with fname |
| 11333 | fun! s:GetTempfile(fname) |
| 11334 | " call Dfunc("s:GetTempfile(fname<".a:fname.">)") |
| 11335 | |
| 11336 | if !exists("b:netrw_tmpfile") |
| 11337 | " get a brand new temporary filename |
| 11338 | let tmpfile= tempname() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11339 | " call Decho("tmpfile<".tmpfile."> : from tempname()",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11340 | |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11341 | let tmpfile= substitute(tmpfile,'\','/','ge') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11342 | " call Decho("tmpfile<".tmpfile."> : chgd any \\ -> /",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11343 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11344 | " sanity check -- does the temporary file's directory exist? |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11345 | if !isdirectory(s:NetrwFile(substitute(tmpfile,'[^/]\+$','','e'))) |
| 11346 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11347 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"your <".substitute(tmpfile,'[^/]\+$','','e')."> directory is missing!",2) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11348 | " call Dret("s:GetTempfile getcwd<".getcwd().">") |
| 11349 | return "" |
| 11350 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11351 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11352 | " let netrw#NetSource() know about the tmpfile |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11353 | let s:netrw_tmpfile= tmpfile " used by netrw#NetSource() and netrw#BrowseX() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11354 | " call Decho("tmpfile<".tmpfile."> s:netrw_tmpfile<".s:netrw_tmpfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11355 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11356 | " o/s dependencies |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11357 | if g:netrw_cygwin != 0 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11358 | let tmpfile = substitute(tmpfile,'^\(\a\):',g:netrw_cygdrive.'/\1','e') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11359 | elseif has("win32") || has("win95") || has("win64") || has("win16") |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11360 | if !exists("+shellslash") || !&ssl |
| 11361 | let tmpfile = substitute(tmpfile,'/','\','g') |
| 11362 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11363 | else |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11364 | let tmpfile = tmpfile |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11365 | endif |
| 11366 | let b:netrw_tmpfile= tmpfile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11367 | " call Decho("o/s dependent fixed tempname<".tmpfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11368 | else |
| 11369 | " re-use temporary filename |
| 11370 | let tmpfile= b:netrw_tmpfile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11371 | " call Decho("tmpfile<".tmpfile."> re-using",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11372 | endif |
| 11373 | |
| 11374 | " use fname's suffix for the temporary file |
| 11375 | if a:fname != "" |
| 11376 | if a:fname =~ '\.[^./]\+$' |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11377 | " call Decho("using fname<".a:fname.">'s suffix",'~'.expand("<slnum>")) |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 11378 | if a:fname =~ '\.tar\.gz$' || a:fname =~ '\.tar\.bz2$' || a:fname =~ '\.tar\.xz$' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11379 | let suffix = ".tar".substitute(a:fname,'^.*\(\.[^./]\+\)$','\1','e') |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 11380 | elseif a:fname =~ '.txz$' |
| 11381 | let suffix = ".txz".substitute(a:fname,'^.*\(\.[^./]\+\)$','\1','e') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11382 | else |
| 11383 | let suffix = substitute(a:fname,'^.*\(\.[^./]\+\)$','\1','e') |
| 11384 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11385 | " call Decho("suffix<".suffix.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11386 | let tmpfile= substitute(tmpfile,'\.tmp$','','e') |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11387 | " call Decho("chgd tmpfile<".tmpfile."> (removed any .tmp suffix)",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11388 | let tmpfile .= suffix |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11389 | " call Decho("chgd tmpfile<".tmpfile."> (added ".suffix." suffix) netrw_fname<".b:netrw_fname.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11390 | let s:netrw_tmpfile= tmpfile " supports netrw#NetSource() |
| 11391 | endif |
| 11392 | endif |
| 11393 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11394 | " call Decho("ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11395 | " call Dret("s:GetTempfile <".tmpfile.">") |
| 11396 | return tmpfile |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11397 | endfun |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11398 | |
| 11399 | " --------------------------------------------------------------------- |
| 11400 | " s:MakeSshCmd: transforms input command using USEPORT HOSTNAME into {{{2 |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11401 | " a correct command for use with a system() call |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11402 | fun! s:MakeSshCmd(sshcmd) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11403 | " call Dfunc("s:MakeSshCmd(sshcmd<".a:sshcmd.">) user<".s:user."> machine<".s:machine.">") |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 11404 | if s:user == "" |
| 11405 | let sshcmd = substitute(a:sshcmd,'\<HOSTNAME\>',s:machine,'') |
| 11406 | else |
| 11407 | let sshcmd = substitute(a:sshcmd,'\<HOSTNAME\>',s:user."@".s:machine,'') |
| 11408 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11409 | if exists("g:netrw_port") && g:netrw_port != "" |
Bram Moolenaar | 7aa9f6a | 2007-05-10 18:00:30 +0000 | [diff] [blame] | 11410 | let sshcmd= substitute(sshcmd,"USEPORT",g:netrw_sshport.' '.g:netrw_port,'') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11411 | elseif exists("s:port") && s:port != "" |
Bram Moolenaar | 7aa9f6a | 2007-05-10 18:00:30 +0000 | [diff] [blame] | 11412 | let sshcmd= substitute(sshcmd,"USEPORT",g:netrw_sshport.' '.s:port,'') |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11413 | else |
| 11414 | let sshcmd= substitute(sshcmd,"USEPORT ",'','') |
| 11415 | endif |
| 11416 | " call Dret("s:MakeSshCmd <".sshcmd.">") |
| 11417 | return sshcmd |
| 11418 | endfun |
| 11419 | |
| 11420 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11421 | " s:MakeBookmark: enters a bookmark into Netrw's bookmark system {{{2 |
| 11422 | fun! s:MakeBookmark(fname) |
| 11423 | " call Dfunc("s:MakeBookmark(fname<".a:fname.">)") |
| 11424 | |
| 11425 | if !exists("g:netrw_bookmarklist") |
| 11426 | let g:netrw_bookmarklist= [] |
| 11427 | endif |
| 11428 | |
| 11429 | if index(g:netrw_bookmarklist,a:fname) == -1 |
| 11430 | " curdir not currently in g:netrw_bookmarklist, so include it |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11431 | if isdirectory(s:NetrwFile(a:fname)) && a:fname !~ '/$' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11432 | call add(g:netrw_bookmarklist,a:fname.'/') |
| 11433 | elseif a:fname !~ '/' |
| 11434 | call add(g:netrw_bookmarklist,getcwd()."/".a:fname) |
| 11435 | else |
| 11436 | call add(g:netrw_bookmarklist,a:fname) |
| 11437 | endif |
| 11438 | call sort(g:netrw_bookmarklist) |
| 11439 | endif |
| 11440 | |
| 11441 | " call Dret("s:MakeBookmark") |
| 11442 | endfun |
| 11443 | |
| 11444 | " --------------------------------------------------------------------- |
| 11445 | " s:MergeBookmarks: merge current bookmarks with saved bookmarks {{{2 |
| 11446 | fun! s:MergeBookmarks() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11447 | " call Dfunc("s:MergeBookmarks() : merge current bookmarks into .netrwbook") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11448 | " get bookmarks from .netrwbook file |
| 11449 | let savefile= s:NetrwHome()."/.netrwbook" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11450 | if filereadable(s:NetrwFile(savefile)) |
| 11451 | " call Decho("merge bookmarks (active and file)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11452 | NetrwKeepj call s:NetrwBookHistSave() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11453 | " call Decho("bookmark delete savefile<".savefile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11454 | NetrwKeepj call delete(savefile) |
| 11455 | endif |
| 11456 | " call Dret("s:MergeBookmarks") |
| 11457 | endfun |
| 11458 | |
| 11459 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11460 | " s:NetrwBMShow: {{{2 |
| 11461 | fun! s:NetrwBMShow() |
| 11462 | " call Dfunc("s:NetrwBMShow()") |
| 11463 | redir => bmshowraw |
| 11464 | menu |
| 11465 | redir END |
| 11466 | let bmshowlist = split(bmshowraw,'\n') |
| 11467 | if bmshowlist != [] |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11468 | let bmshowfuncs= filter(bmshowlist,'v:val =~# "<SNR>\\d\\+_BMShow()"') |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11469 | if bmshowfuncs != [] |
| 11470 | let bmshowfunc = substitute(bmshowfuncs[0],'^.*:\(call.*BMShow()\).*$','\1','') |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11471 | if bmshowfunc =~# '^call.*BMShow()' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11472 | exe "sil! NetrwKeepj ".bmshowfunc |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11473 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11474 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11475 | endif |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11476 | " call Dret("s:NetrwBMShow : bmshowfunc<".(exists("bmshowfunc")? bmshowfunc : 'n/a').">") |
| 11477 | endfun |
| 11478 | |
| 11479 | " --------------------------------------------------------------------- |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11480 | " s:NetrwCursor: responsible for setting cursorline/cursorcolumn based upon g:netrw_cursor {{{2 |
| 11481 | fun! s:NetrwCursor() |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 11482 | if !exists("w:netrw_liststyle") |
| 11483 | let w:netrw_liststyle= g:netrw_liststyle |
| 11484 | endif |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11485 | " call Dfunc("s:NetrwCursor() ft<".&ft."> liststyle=".w:netrw_liststyle." g:netrw_cursor=".g:netrw_cursor." s:netrw_usercuc=".s:netrw_usercuc." s:netrw_usercul=".s:netrw_usercul) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11486 | |
| 11487 | if &ft != "netrw" |
| 11488 | " if the current window isn't a netrw directory listing window, then use user cursorline/column |
| 11489 | " settings. Affects when netrw is used to read/write a file using scp/ftp/etc. |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11490 | " call Decho("case ft!=netrw: use user cul,cuc",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11491 | let &l:cursorline = s:netrw_usercul |
| 11492 | let &l:cursorcolumn = s:netrw_usercuc |
| 11493 | |
| 11494 | elseif g:netrw_cursor == 4 |
| 11495 | " all styles: cursorline, cursorcolumn |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11496 | " call Decho("case g:netrw_cursor==4: setl cul cuc",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11497 | setl cursorline |
| 11498 | setl cursorcolumn |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11499 | |
| 11500 | elseif g:netrw_cursor == 3 |
| 11501 | " thin-long-tree: cursorline, user's cursorcolumn |
| 11502 | " wide : cursorline, cursorcolumn |
| 11503 | if w:netrw_liststyle == s:WIDELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11504 | " call Decho("case g:netrw_cursor==3 and wide: setl cul cuc",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11505 | setl cursorline |
| 11506 | setl cursorcolumn |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11507 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11508 | " call Decho("case g:netrw_cursor==3 and not wide: setl cul (use user's cuc)",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11509 | setl cursorline |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11510 | let &l:cursorcolumn = s:netrw_usercuc |
| 11511 | endif |
| 11512 | |
| 11513 | elseif g:netrw_cursor == 2 |
| 11514 | " thin-long-tree: cursorline, user's cursorcolumn |
| 11515 | " wide : cursorline, user's cursorcolumn |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11516 | " call Decho("case g:netrw_cursor==2: setl cuc (use user's cul)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11517 | let &l:cursorcolumn = s:netrw_usercuc |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11518 | setl cursorline |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11519 | |
| 11520 | elseif g:netrw_cursor == 1 |
| 11521 | " thin-long-tree: user's cursorline, user's cursorcolumn |
| 11522 | " wide : cursorline, user's cursorcolumn |
| 11523 | let &l:cursorcolumn = s:netrw_usercuc |
| 11524 | if w:netrw_liststyle == s:WIDELIST |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11525 | " call Decho("case g:netrw_cursor==2 and wide: setl cul (use user's cuc)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11526 | setl cursorline |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11527 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11528 | " call Decho("case g:netrw_cursor==2 and not wide: (use user's cul,cuc)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11529 | let &l:cursorline = s:netrw_usercul |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 11530 | endif |
| 11531 | |
| 11532 | else |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11533 | " all styles: user's cursorline, user's cursorcolumn |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11534 | " call Decho("default: (use user's cul,cuc)",'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11535 | let &l:cursorline = s:netrw_usercul |
| 11536 | let &l:cursorcolumn = s:netrw_usercuc |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 11537 | endif |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11538 | |
| 11539 | " call Dret("s:NetrwCursor : l:cursorline=".&l:cursorline." l:cursorcolumn=".&l:cursorcolumn) |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 11540 | endfun |
| 11541 | |
| 11542 | " --------------------------------------------------------------------- |
| 11543 | " s:RestoreCursorline: restores cursorline/cursorcolumn to original user settings {{{2 |
| 11544 | fun! s:RestoreCursorline() |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11545 | " call Dfunc("s:RestoreCursorline() currently, cul=".&l:cursorline." cuc=".&l:cursorcolumn." win#".winnr()." buf#".bufnr("%")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11546 | if exists("s:netrw_usercul") |
| 11547 | let &l:cursorline = s:netrw_usercul |
| 11548 | endif |
| 11549 | if exists("s:netrw_usercuc") |
| 11550 | let &l:cursorcolumn = s:netrw_usercuc |
| 11551 | endif |
Bram Moolenaar | 00a927d | 2010-05-14 23:24:24 +0200 | [diff] [blame] | 11552 | " call Dret("s:RestoreCursorline : restored cul=".&l:cursorline." cuc=".&l:cursorcolumn) |
| 11553 | endfun |
| 11554 | |
| 11555 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11556 | " s:NetrwDelete: Deletes a file. {{{2 |
| 11557 | " Uses Steve Hall's idea to insure that Windows paths stay |
| 11558 | " acceptable. No effect on Unix paths. |
| 11559 | " Examples of use: let result= s:NetrwDelete(path) |
| 11560 | fun! s:NetrwDelete(path) |
| 11561 | " call Dfunc("s:NetrwDelete(path<".a:path.">)") |
| 11562 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11563 | let path = netrw#WinPath(a:path) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11564 | if !g:netrw_cygwin && (has("win32") || has("win95") || has("win64") || has("win16")) |
| 11565 | if exists("+shellslash") |
| 11566 | let sskeep= &shellslash |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 11567 | setl noshellslash |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11568 | let result = delete(path) |
| 11569 | let &shellslash = sskeep |
| 11570 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11571 | " call Decho("exe let result= ".a:cmd."('".path."')",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11572 | let result= delete(path) |
| 11573 | endif |
| 11574 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11575 | " call Decho("let result= delete(".path.")",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11576 | let result= delete(path) |
| 11577 | endif |
| 11578 | if result < 0 |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11579 | NetrwKeepj call netrw#ErrorMsg(s:WARNING,"delete(".path.") failed!",71) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11580 | endif |
| 11581 | |
| 11582 | " call Dret("s:NetrwDelete ".result) |
| 11583 | return result |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11584 | endfun |
| 11585 | |
| 11586 | " --------------------------------------------------------------------- |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11587 | " s:NetrwEnew: opens a new buffer, passes netrw buffer variables through {{{2 |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11588 | fun! s:NetrwEnew(...) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11589 | " call Dfunc("s:NetrwEnew() a:0=".a:0." bufnr($)=".bufnr("$")." expand(%)<".expand("%").">") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11590 | " call Decho("curdir<".((a:0>0)? a:1 : "")."> buf#".bufnr("%")."<".bufname("%").">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11591 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11592 | " grab a function-local-variable copy of buffer variables |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11593 | " call Decho("make function-local copy of netrw variables",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11594 | if exists("b:netrw_bannercnt") |let netrw_bannercnt = b:netrw_bannercnt |endif |
| 11595 | if exists("b:netrw_browser_active") |let netrw_browser_active = b:netrw_browser_active |endif |
| 11596 | if exists("b:netrw_cpf") |let netrw_cpf = b:netrw_cpf |endif |
| 11597 | if exists("b:netrw_curdir") |let netrw_curdir = b:netrw_curdir |endif |
| 11598 | if exists("b:netrw_explore_bufnr") |let netrw_explore_bufnr = b:netrw_explore_bufnr |endif |
| 11599 | if exists("b:netrw_explore_indx") |let netrw_explore_indx = b:netrw_explore_indx |endif |
| 11600 | if exists("b:netrw_explore_line") |let netrw_explore_line = b:netrw_explore_line |endif |
| 11601 | if exists("b:netrw_explore_list") |let netrw_explore_list = b:netrw_explore_list |endif |
| 11602 | if exists("b:netrw_explore_listlen")|let netrw_explore_listlen = b:netrw_explore_listlen|endif |
| 11603 | if exists("b:netrw_explore_mtchcnt")|let netrw_explore_mtchcnt = b:netrw_explore_mtchcnt|endif |
| 11604 | if exists("b:netrw_fname") |let netrw_fname = b:netrw_fname |endif |
| 11605 | if exists("b:netrw_lastfile") |let netrw_lastfile = b:netrw_lastfile |endif |
| 11606 | if exists("b:netrw_liststyle") |let netrw_liststyle = b:netrw_liststyle |endif |
| 11607 | if exists("b:netrw_method") |let netrw_method = b:netrw_method |endif |
| 11608 | if exists("b:netrw_option") |let netrw_option = b:netrw_option |endif |
| 11609 | if exists("b:netrw_prvdir") |let netrw_prvdir = b:netrw_prvdir |endif |
| 11610 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11611 | NetrwKeepj call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11612 | " call Decho("generate a buffer with NetrwKeepj keepalt enew!",'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11613 | " when tree listing uses file TreeListing... a new buffer is made. |
| 11614 | " Want the old buffer to be unlisted. |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11615 | " COMBAK: this causes a problem, see P43 |
| 11616 | " setl nobl |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 11617 | let netrw_keepdiff= &l:diff |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11618 | noswapfile NetrwKeepj keepalt enew! |
Bram Moolenaar | 5ac3b1a | 2010-07-27 22:50:36 +0200 | [diff] [blame] | 11619 | let &l:diff= netrw_keepdiff |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11620 | " call Decho("bufnr($)=".bufnr("$")."<".bufname(bufnr("$"))."> winnr($)=".winnr("$"),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11621 | NetrwKeepj call s:NetrwOptionSave("w:") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11622 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11623 | " copy function-local-variables to buffer variable equivalents |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11624 | " call Decho("copy function-local variables back to buffer netrw variables",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11625 | if exists("netrw_bannercnt") |let b:netrw_bannercnt = netrw_bannercnt |endif |
| 11626 | if exists("netrw_browser_active") |let b:netrw_browser_active = netrw_browser_active |endif |
| 11627 | if exists("netrw_cpf") |let b:netrw_cpf = netrw_cpf |endif |
| 11628 | if exists("netrw_curdir") |let b:netrw_curdir = netrw_curdir |endif |
| 11629 | if exists("netrw_explore_bufnr") |let b:netrw_explore_bufnr = netrw_explore_bufnr |endif |
| 11630 | if exists("netrw_explore_indx") |let b:netrw_explore_indx = netrw_explore_indx |endif |
| 11631 | if exists("netrw_explore_line") |let b:netrw_explore_line = netrw_explore_line |endif |
| 11632 | if exists("netrw_explore_list") |let b:netrw_explore_list = netrw_explore_list |endif |
| 11633 | if exists("netrw_explore_listlen")|let b:netrw_explore_listlen = netrw_explore_listlen|endif |
| 11634 | if exists("netrw_explore_mtchcnt")|let b:netrw_explore_mtchcnt = netrw_explore_mtchcnt|endif |
| 11635 | if exists("netrw_fname") |let b:netrw_fname = netrw_fname |endif |
| 11636 | if exists("netrw_lastfile") |let b:netrw_lastfile = netrw_lastfile |endif |
| 11637 | if exists("netrw_liststyle") |let b:netrw_liststyle = netrw_liststyle |endif |
| 11638 | if exists("netrw_method") |let b:netrw_method = netrw_method |endif |
| 11639 | if exists("netrw_option") |let b:netrw_option = netrw_option |endif |
| 11640 | if exists("netrw_prvdir") |let b:netrw_prvdir = netrw_prvdir |endif |
| 11641 | |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11642 | if a:0 > 0 |
| 11643 | let b:netrw_curdir= a:1 |
| 11644 | if b:netrw_curdir =~ '/$' |
| 11645 | if exists("w:netrw_liststyle") && w:netrw_liststyle == s:TREELIST |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11646 | setl nobl |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11647 | file NetrwTreeListing |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11648 | setl nobl bt=nowrite bh=hide |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11649 | nno <silent> <buffer> [ :sil call <SID>TreeListMove('[')<cr> |
| 11650 | nno <silent> <buffer> ] :sil call <SID>TreeListMove(']')<cr> |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11651 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11652 | call s:NetrwBufRename(b:netrw_curdir) |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11653 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11654 | endif |
| 11655 | endif |
| 11656 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11657 | " call Dret("s:NetrwEnew : buf#".bufnr("%")."<".bufname("%")."> expand(%)<".expand("%")."> expand(#)<".expand("#")."> bh=".&bh." win#".winnr()." winnr($)#".winnr("$")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11658 | endfun |
| 11659 | |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11660 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11661 | " s:NetrwExe: executes a string using "!" {{{2 |
| 11662 | fun! s:NetrwExe(cmd) |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11663 | " call Dfunc("s:NetrwExe(a:cmd<".a:cmd.">)") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11664 | if has("win32") && &shell !~? 'cmd' && !g:netrw_cygwin |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11665 | " call Decho("using win32:",expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11666 | let savedShell=[&shell,&shellcmdflag,&shellxquote,&shellxescape,&shellquote,&shellpipe,&shellredir,&shellslash] |
| 11667 | set shell& shellcmdflag& shellxquote& shellxescape& |
| 11668 | set shellquote& shellpipe& shellredir& shellslash& |
| 11669 | exe a:cmd |
| 11670 | let [&shell,&shellcmdflag,&shellxquote,&shellxescape,&shellquote,&shellpipe,&shellredir,&shellslash] = savedShell |
| 11671 | else |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11672 | " call Decho("exe ".a:cmd,'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11673 | exe a:cmd |
| 11674 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11675 | " call Dret("s:NetrwExe : v:shell_error=".v:shell_error) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11676 | endfun |
| 11677 | |
| 11678 | " --------------------------------------------------------------------- |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11679 | " s:NetrwInsureWinVars: insure that a netrw buffer has its w: variables in spite of a wincmd v or s {{{2 |
| 11680 | fun! s:NetrwInsureWinVars() |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11681 | if !exists("w:netrw_liststyle") |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11682 | " call Dfunc("s:NetrwInsureWinVars() win#".winnr()) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11683 | let curbuf = bufnr("%") |
| 11684 | let curwin = winnr() |
| 11685 | let iwin = 1 |
| 11686 | while iwin <= winnr("$") |
| 11687 | exe iwin."wincmd w" |
| 11688 | if winnr() != curwin && bufnr("%") == curbuf && exists("w:netrw_liststyle") |
| 11689 | " looks like ctrl-w_s or ctrl-w_v was used to split a netrw buffer |
| 11690 | let winvars= w: |
| 11691 | break |
| 11692 | endif |
| 11693 | let iwin= iwin + 1 |
| 11694 | endwhile |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 11695 | exe "keepalt ".curwin."wincmd w" |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11696 | if exists("winvars") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11697 | " call Decho("copying w#".iwin." window variables to w#".curwin,'~'.expand("<slnum>")) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11698 | for k in keys(winvars) |
| 11699 | let w:{k}= winvars[k] |
| 11700 | endfor |
| 11701 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11702 | " call Dret("s:NetrwInsureWinVars win#".winnr()) |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11703 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11704 | endfun |
| 11705 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11706 | " --------------------------------------------------------------------- |
| 11707 | " s:NetrwLcd: handles changing the (local) directory {{{2 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11708 | " Returns: 0=success |
| 11709 | " -1=failed |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11710 | fun! s:NetrwLcd(newdir) |
| 11711 | " call Dfunc("s:NetrwLcd(newdir<".a:newdir.">)") |
| 11712 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11713 | let err472= 0 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11714 | try |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11715 | exe 'NetrwKeepj sil lcd '.fnameescape(a:newdir) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11716 | catch /^Vim\%((\a\+)\)\=:E344/ |
| 11717 | " Vim's lcd fails with E344 when attempting to go above the 'root' of a Windows share. |
| 11718 | " Therefore, detect if a Windows share is present, and if E344 occurs, just settle at |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11719 | " 'root' (ie. '\'). The share name may start with either backslashes ('\\Foo') or |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11720 | " forward slashes ('//Foo'), depending on whether backslashes have been converted to |
| 11721 | " forward slashes by earlier code; so check for both. |
| 11722 | if (has("win32") || has("win95") || has("win64") || has("win16")) && !g:netrw_cygwin |
| 11723 | if a:newdir =~ '^\\\\\w\+' || a:newdir =~ '^//\w\+' |
| 11724 | let dirname = '\' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11725 | exe 'NetrwKeepj sil lcd '.fnameescape(dirname) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11726 | endif |
| 11727 | endif |
| 11728 | catch /^Vim\%((\a\+)\)\=:E472/ |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11729 | let err472= 1 |
| 11730 | endtry |
| 11731 | |
| 11732 | if err472 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11733 | call netrw#ErrorMsg(s:ERROR,"unable to change directory to <".a:newdir."> (permissions?)",61) |
| 11734 | if exists("w:netrw_prvdir") |
| 11735 | let a:newdir= w:netrw_prvdir |
| 11736 | else |
| 11737 | call s:NetrwOptionRestore("w:") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11738 | " call Decho("setl noma nomod nowrap",'~'.expand("<slnum>")) |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 11739 | exe "setl ".g:netrw_bufsettings |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11740 | " call Decho(" ro=".&l:ro." ma=".&l:ma." mod=".&l:mod." wrap=".&l:wrap." (filename<".expand("%")."> win#".winnr()." ft<".&ft.">)",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11741 | let a:newdir= dirname |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11742 | endif |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11743 | " call Dret("s:NetrwBrowse -1 : reusing buffer#".(exists("bufnum")? bufnum : 'N/A')."<".dirname."> getcwd<".getcwd().">") |
| 11744 | return -1 |
| 11745 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11746 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11747 | " call Dret("s:NetrwLcd 0") |
| 11748 | return 0 |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11749 | endfun |
| 11750 | |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11751 | " ------------------------------------------------------------------------ |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11752 | " s:NetrwSaveWordPosn: used to keep cursor on same word after refresh, {{{2 |
| 11753 | " changed sorting, etc. Also see s:NetrwRestoreWordPosn(). |
| 11754 | fun! s:NetrwSaveWordPosn() |
| 11755 | " call Dfunc("NetrwSaveWordPosn()") |
| 11756 | let s:netrw_saveword= '^'.fnameescape(getline('.')).'$' |
| 11757 | " call Dret("NetrwSaveWordPosn : saveword<".s:netrw_saveword.">") |
| 11758 | endfun |
| 11759 | |
| 11760 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11761 | " s:NetrwHumanReadable: takes a number and makes it "human readable" {{{2 |
| 11762 | " 1000 -> 1K, 1000000 -> 1M, 1000000000 -> 1G |
| 11763 | fun! s:NetrwHumanReadable(sz) |
| 11764 | " call Dfunc("s:NetrwHumanReadable(sz=".a:sz.") type=".type(a:sz)." style=".g:netrw_sizestyle ) |
| 11765 | |
| 11766 | if g:netrw_sizestyle == 'h' |
| 11767 | if a:sz >= 1000000000 |
| 11768 | let sz = printf("%.1f",a:sz/1000000000.0)."g" |
| 11769 | elseif a:sz >= 10000000 |
| 11770 | let sz = printf("%d",a:sz/1000000)."m" |
| 11771 | elseif a:sz >= 1000000 |
| 11772 | let sz = printf("%.1f",a:sz/1000000.0)."m" |
| 11773 | elseif a:sz >= 10000 |
| 11774 | let sz = printf("%d",a:sz/1000)."k" |
| 11775 | elseif a:sz >= 1000 |
| 11776 | let sz = printf("%.1f",a:sz/1000.0)."k" |
| 11777 | else |
| 11778 | let sz= a:sz |
| 11779 | endif |
| 11780 | |
| 11781 | elseif g:netrw_sizestyle == 'H' |
| 11782 | if a:sz >= 1073741824 |
| 11783 | let sz = printf("%.1f",a:sz/1073741824.0)."G" |
| 11784 | elseif a:sz >= 10485760 |
| 11785 | let sz = printf("%d",a:sz/1048576)."M" |
| 11786 | elseif a:sz >= 1048576 |
| 11787 | let sz = printf("%.1f",a:sz/1048576.0)."M" |
| 11788 | elseif a:sz >= 10240 |
| 11789 | let sz = printf("%d",a:sz/1024)."K" |
| 11790 | elseif a:sz >= 1024 |
| 11791 | let sz = printf("%.1f",a:sz/1024.0)."K" |
| 11792 | else |
| 11793 | let sz= a:sz |
| 11794 | endif |
| 11795 | |
| 11796 | else |
| 11797 | let sz= a:sz |
| 11798 | endif |
| 11799 | |
| 11800 | " call Dret("s:NetrwHumanReadable ".sz) |
| 11801 | return sz |
| 11802 | endfun |
| 11803 | |
| 11804 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11805 | " s:NetrwRestoreWordPosn: used to keep cursor on same word after refresh, {{{2 |
| 11806 | " changed sorting, etc. Also see s:NetrwSaveWordPosn(). |
| 11807 | fun! s:NetrwRestoreWordPosn() |
| 11808 | " call Dfunc("NetrwRestoreWordPosn()") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11809 | sil! call search(s:netrw_saveword,'w') |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11810 | " call Dret("NetrwRestoreWordPosn") |
| 11811 | endfun |
| 11812 | |
| 11813 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11814 | " s:RestoreBufVars: {{{2 |
| 11815 | fun! s:RestoreBufVars() |
| 11816 | " call Dfunc("s:RestoreBufVars()") |
| 11817 | |
| 11818 | if exists("s:netrw_curdir") |let b:netrw_curdir = s:netrw_curdir |endif |
| 11819 | if exists("s:netrw_lastfile") |let b:netrw_lastfile = s:netrw_lastfile |endif |
| 11820 | if exists("s:netrw_method") |let b:netrw_method = s:netrw_method |endif |
| 11821 | if exists("s:netrw_fname") |let b:netrw_fname = s:netrw_fname |endif |
| 11822 | if exists("s:netrw_machine") |let b:netrw_machine = s:netrw_machine |endif |
| 11823 | if exists("s:netrw_browser_active")|let b:netrw_browser_active = s:netrw_browser_active|endif |
| 11824 | |
| 11825 | " call Dret("s:RestoreBufVars") |
| 11826 | endfun |
| 11827 | |
| 11828 | " --------------------------------------------------------------------- |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11829 | " s:RemotePathAnalysis: {{{2 |
| 11830 | fun! s:RemotePathAnalysis(dirname) |
Bram Moolenaar | 251e191 | 2011-06-19 05:09:16 +0200 | [diff] [blame] | 11831 | " call Dfunc("s:RemotePathAnalysis(a:dirname<".a:dirname.">)") |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11832 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11833 | " method :// user @ machine :port /path |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11834 | let dirpat = '^\(\w\{-}\)://\(\(\w\+\)@\)\=\([^/:#]\+\)\%([:#]\(\d\+\)\)\=/\(.*\)$' |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11835 | let s:method = substitute(a:dirname,dirpat,'\1','') |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11836 | let s:user = substitute(a:dirname,dirpat,'\3','') |
| 11837 | let s:machine = substitute(a:dirname,dirpat,'\4','') |
| 11838 | let s:port = substitute(a:dirname,dirpat,'\5','') |
| 11839 | let s:path = substitute(a:dirname,dirpat,'\6','') |
Bram Moolenaar | 1360030 | 2014-05-22 18:26:40 +0200 | [diff] [blame] | 11840 | let s:fname = substitute(s:path,'^.*/\ze.','','') |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11841 | if s:machine =~ '@' |
| 11842 | let dirpat = '^\(.*\)@\(.\{-}\)$' |
| 11843 | let s:user = s:user.'@'.substitute(s:machine,dirpat,'\1','') |
| 11844 | let s:machine = substitute(s:machine,dirpat,'\2','') |
| 11845 | endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11846 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11847 | " call Decho("set up s:method <".s:method .">",'~'.expand("<slnum>")) |
| 11848 | " call Decho("set up s:user <".s:user .">",'~'.expand("<slnum>")) |
| 11849 | " call Decho("set up s:machine<".s:machine.">",'~'.expand("<slnum>")) |
| 11850 | " call Decho("set up s:port <".s:port.">",'~'.expand("<slnum>")) |
| 11851 | " call Decho("set up s:path <".s:path .">",'~'.expand("<slnum>")) |
| 11852 | " call Decho("set up s:fname <".s:fname .">",'~'.expand("<slnum>")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11853 | |
| 11854 | " call Dret("s:RemotePathAnalysis") |
| 11855 | endfun |
| 11856 | |
| 11857 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11858 | " s:RemoteSystem: runs a command on a remote host using ssh {{{2 |
| 11859 | " Returns status |
| 11860 | " Runs system() on |
| 11861 | " [cd REMOTEDIRPATH;] a:cmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11862 | " Note that it doesn't do s:ShellEscape(a:cmd)! |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11863 | fun! s:RemoteSystem(cmd) |
| 11864 | " call Dfunc("s:RemoteSystem(cmd<".a:cmd.">)") |
| 11865 | if !executable(g:netrw_ssh_cmd) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11866 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"g:netrw_ssh_cmd<".g:netrw_ssh_cmd."> is not executable!",52) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11867 | elseif !exists("b:netrw_curdir") |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11868 | NetrwKeepj call netrw#ErrorMsg(s:ERROR,"for some reason b:netrw_curdir doesn't exist!",53) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11869 | else |
| 11870 | let cmd = s:MakeSshCmd(g:netrw_ssh_cmd." USEPORT HOSTNAME") |
| 11871 | let remotedir= substitute(b:netrw_curdir,'^.*//[^/]\+/\(.*\)$','\1','') |
| 11872 | if remotedir != "" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11873 | let cmd= cmd.' cd '.s:ShellEscape(remotedir).";" |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11874 | else |
| 11875 | let cmd= cmd.' ' |
| 11876 | endif |
| 11877 | let cmd= cmd.a:cmd |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11878 | " call Decho("call system(".cmd.")",'~'.expand("<slnum>")) |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 11879 | let ret= system(cmd) |
| 11880 | endif |
| 11881 | " call Dret("s:RemoteSystem ".ret) |
| 11882 | return ret |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11883 | endfun |
| 11884 | |
| 11885 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11886 | " s:RestoreWinVars: (used by Explore() and NetrwSplit()) {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11887 | fun! s:RestoreWinVars() |
| 11888 | " call Dfunc("s:RestoreWinVars()") |
Bram Moolenaar | 488c651 | 2005-08-11 20:09:58 +0000 | [diff] [blame] | 11889 | if exists("s:bannercnt") |let w:netrw_bannercnt = s:bannercnt |unlet s:bannercnt |endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11890 | if exists("s:col") |let w:netrw_col = s:col |unlet s:col |endif |
| 11891 | if exists("s:curdir") |let w:netrw_curdir = s:curdir |unlet s:curdir |endif |
| 11892 | if exists("s:explore_bufnr") |let w:netrw_explore_bufnr = s:explore_bufnr |unlet s:explore_bufnr |endif |
| 11893 | if exists("s:explore_indx") |let w:netrw_explore_indx = s:explore_indx |unlet s:explore_indx |endif |
| 11894 | if exists("s:explore_line") |let w:netrw_explore_line = s:explore_line |unlet s:explore_line |endif |
| 11895 | if exists("s:explore_listlen")|let w:netrw_explore_listlen = s:explore_listlen|unlet s:explore_listlen|endif |
| 11896 | if exists("s:explore_list") |let w:netrw_explore_list = s:explore_list |unlet s:explore_list |endif |
| 11897 | if exists("s:explore_mtchcnt")|let w:netrw_explore_mtchcnt = s:explore_mtchcnt|unlet s:explore_mtchcnt|endif |
| 11898 | if exists("s:fpl") |let w:netrw_fpl = s:fpl |unlet s:fpl |endif |
| 11899 | if exists("s:hline") |let w:netrw_hline = s:hline |unlet s:hline |endif |
| 11900 | if exists("s:line") |let w:netrw_line = s:line |unlet s:line |endif |
| 11901 | if exists("s:liststyle") |let w:netrw_liststyle = s:liststyle |unlet s:liststyle |endif |
Bram Moolenaar | 488c651 | 2005-08-11 20:09:58 +0000 | [diff] [blame] | 11902 | if exists("s:method") |let w:netrw_method = s:method |unlet s:method |endif |
| 11903 | if exists("s:prvdir") |let w:netrw_prvdir = s:prvdir |unlet s:prvdir |endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11904 | if exists("s:treedict") |let w:netrw_treedict = s:treedict |unlet s:treedict |endif |
| 11905 | if exists("s:treetop") |let w:netrw_treetop = s:treetop |unlet s:treetop |endif |
| 11906 | if exists("s:winnr") |let w:netrw_winnr = s:winnr |unlet s:winnr |endif |
| 11907 | " call Dret("s:RestoreWinVars") |
Bram Moolenaar | 488c651 | 2005-08-11 20:09:58 +0000 | [diff] [blame] | 11908 | endfun |
| 11909 | |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 11910 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11911 | " s:Rexplore: implements returning from a buffer to a netrw directory {{{2 |
| 11912 | " |
| 11913 | " s:SetRexDir() sets up <2-leftmouse> maps (if g:netrw_retmap |
| 11914 | " is true) and a command, :Rexplore, which call this function. |
| 11915 | " |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11916 | " s:netrw_posn is set up by s:NetrwBrowseChgDir() |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11917 | " |
| 11918 | " s:rexposn_BUFNR used to save/restore cursor position |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11919 | fun! s:NetrwRexplore(islocal,dirname) |
Bram Moolenaar | ff03419 | 2013-04-24 18:51:19 +0200 | [diff] [blame] | 11920 | if exists("s:netrwdrag") |
| 11921 | return |
| 11922 | endif |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11923 | " call Dfunc("s:NetrwRexplore() w:netrw_rexlocal=".w:netrw_rexlocal." w:netrw_rexdir<".w:netrw_rexdir."> win#".winnr()) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11924 | " call Decho("currently in bufname<".bufname("%").">",'~'.expand("<slnum>")) |
| 11925 | " call Decho("ft=".&ft." win#".winnr()." w:netrw_rexfile<".(exists("w:netrw_rexfile")? w:netrw_rexfile : 'n/a').">",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11926 | |
| 11927 | if &ft == "netrw" && exists("w:netrw_rexfile") && w:netrw_rexfile != "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11928 | " a :Rex while in a netrw buffer means: edit the file in w:netrw_rexfile |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11929 | " call Decho("in netrw buffer, will edit file<".w:netrw_rexfile.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11930 | exe "NetrwKeepj e ".w:netrw_rexfile |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11931 | unlet w:netrw_rexfile |
| 11932 | " call Dret("s:NetrwRexplore returning from netrw to buf#".bufnr("%")."<".bufname("%")."> (ft=".&ft.")") |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11933 | return |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11934 | " else " Decho |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11935 | " call Decho("treating as not-netrw-buffer: ft=".&ft.((&ft == "netrw")? " == netrw" : "!= netrw"),'~'.expand("<slnum>")) |
| 11936 | " call Decho("treating as not-netrw-buffer: w:netrw_rexfile<".((exists("w:netrw_rexfile"))? w:netrw_rexfile : 'n/a').">",'~'.expand("<slnum>")) |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11937 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11938 | |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11939 | " --------------------------- |
| 11940 | " :Rex issued while in a file |
| 11941 | " --------------------------- |
| 11942 | |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11943 | " record current file so :Rex can return to it from netrw |
| 11944 | let w:netrw_rexfile= expand("%") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11945 | " call Decho("set w:netrw_rexfile<".w:netrw_rexfile."> (win#".winnr().")",'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11946 | |
| 11947 | if !exists("w:netrw_rexlocal") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11948 | " call Dret("s:NetrwRexplore w:netrw_rexlocal doesn't exist (".&ft." win#".winnr().")") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11949 | return |
| 11950 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11951 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 11952 | if w:netrw_rexlocal |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11953 | NetrwKeepj call netrw#LocalBrowseCheck(w:netrw_rexdir) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11954 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11955 | NetrwKeepj call s:NetrwBrowse(0,w:netrw_rexdir) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11956 | endif |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11957 | if exists("s:initbeval") |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11958 | setl beval |
Bram Moolenaar | 1514667 | 2011-10-20 22:22:38 +0200 | [diff] [blame] | 11959 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11960 | if exists("s:rexposn_".bufnr("%")) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11961 | " call Decho("restore posn, then unlet s:rexposn_".bufnr('%')."<".bufname("%").">",'~'.expand("<slnum>")) |
| 11962 | " restore position in directory listing |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 11963 | " call Decho("restoring posn to s:rexposn_".bufnr('%')."<".string(s:rexposn_{bufnr('%')}).">",'~'.expand("<slnum>")) |
| 11964 | NetrwKeepj call winrestview(s:rexposn_{bufnr('%')}) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11965 | if exists("s:rexposn_".bufnr('%')) |
| 11966 | unlet s:rexposn_{bufnr('%')} |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 11967 | endif |
Bram Moolenaar | 5b435d6 | 2012-04-05 17:33:26 +0200 | [diff] [blame] | 11968 | else |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11969 | " call Decho("s:rexposn_".bufnr('%')."<".bufname("%")."> doesn't exist",'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11970 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11971 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 11972 | if has("syntax") && exists("g:syntax_on") && g:syntax_on |
| 11973 | if exists("s:explore_match") |
| 11974 | exe "2match netrwMarkFile /".s:explore_match."/" |
| 11975 | endif |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11976 | endif |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11977 | |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 11978 | " call Decho("settings buf#".bufnr("%")."<".bufname("%").">: ".((&l:ma == 0)? "no" : "")."ma ".((&l:mod == 0)? "no" : "")."mod ".((&l:bl == 0)? "no" : "")."bl ".((&l:ro == 0)? "no" : "")."ro fo=".&l:fo,'~'.expand("<slnum>")) |
Bram Moolenaar | a687837 | 2014-03-22 21:02:50 +0100 | [diff] [blame] | 11979 | " call Dret("s:NetrwRexplore : ft=".&ft) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 11980 | endfun |
| 11981 | |
| 11982 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 11983 | " s:SaveBufVars: save selected b: variables to s: variables {{{2 |
| 11984 | " use s:RestoreBufVars() to restore b: variables from s: variables |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11985 | fun! s:SaveBufVars() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 11986 | " call Dfunc("s:SaveBufVars() buf#".bufnr("%")) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 11987 | |
| 11988 | if exists("b:netrw_curdir") |let s:netrw_curdir = b:netrw_curdir |endif |
| 11989 | if exists("b:netrw_lastfile") |let s:netrw_lastfile = b:netrw_lastfile |endif |
| 11990 | if exists("b:netrw_method") |let s:netrw_method = b:netrw_method |endif |
| 11991 | if exists("b:netrw_fname") |let s:netrw_fname = b:netrw_fname |endif |
| 11992 | if exists("b:netrw_machine") |let s:netrw_machine = b:netrw_machine |endif |
| 11993 | if exists("b:netrw_browser_active")|let s:netrw_browser_active = b:netrw_browser_active|endif |
| 11994 | |
| 11995 | " call Dret("s:SaveBufVars") |
| 11996 | endfun |
| 11997 | |
| 11998 | " --------------------------------------------------------------------- |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 11999 | " s:SavePosn: saves position associated with current buffer into a dictionary {{{2 |
| 12000 | fun! s:SavePosn(posndict) |
| 12001 | " call Dfunc("s:SavePosn(posndict) curbuf#".bufnr("%")."<".bufname("%").">") |
| 12002 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12003 | if !exists("a:posndict[bufnr('%')]") |
| 12004 | let a:posndict[bufnr("%")]= [] |
| 12005 | endif |
| 12006 | " call Decho("before push: a:posndict[buf#".bufnr("%")."]=".string(a:posndict[bufnr('%')])) |
| 12007 | call add(a:posndict[bufnr("%")],winsaveview()) |
| 12008 | " call Decho("after push: a:posndict[buf#".bufnr("%")."]=".string(a:posndict[bufnr('%')])) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 12009 | |
| 12010 | " call Dret("s:SavePosn posndict") |
| 12011 | return a:posndict |
| 12012 | endfun |
| 12013 | |
| 12014 | " --------------------------------------------------------------------- |
| 12015 | " s:RestorePosn: restores position associated with current buffer using dictionary {{{2 |
| 12016 | fun! s:RestorePosn(posndict) |
| 12017 | " call Dfunc("s:RestorePosn(posndict) curbuf#".bufnr("%")."<".bufname("%").">") |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12018 | if exists("a:posndict") |
| 12019 | if has_key(a:posndict,bufnr("%")) |
| 12020 | " call Decho("before pop: a:posndict[buf#".bufnr("%")."]=".string(a:posndict[bufnr('%')])) |
| 12021 | let posnlen= len(a:posndict[bufnr("%")]) |
| 12022 | if posnlen > 0 |
| 12023 | let posnlen= posnlen - 1 |
| 12024 | " call Decho("restoring posn posndict[".bufnr("%")."][".posnlen."]=".string(a:posndict[bufnr("%")][posnlen]),'~'.expand("<slnum>")) |
| 12025 | call winrestview(a:posndict[bufnr("%")][posnlen]) |
| 12026 | call remove(a:posndict[bufnr("%")],posnlen) |
| 12027 | " call Decho("after pop: a:posndict[buf#".bufnr("%")."]=".string(a:posndict[bufnr('%')])) |
| 12028 | endif |
| 12029 | endif |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 12030 | endif |
| 12031 | " call Dret("s:RestorePosn") |
| 12032 | endfun |
| 12033 | |
| 12034 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12035 | " s:SaveWinVars: (used by Explore() and NetrwSplit()) {{{2 |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 12036 | fun! s:SaveWinVars() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 12037 | " call Dfunc("s:SaveWinVars() win#".winnr()) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 12038 | if exists("w:netrw_bannercnt") |let s:bannercnt = w:netrw_bannercnt |endif |
| 12039 | if exists("w:netrw_col") |let s:col = w:netrw_col |endif |
| 12040 | if exists("w:netrw_curdir") |let s:curdir = w:netrw_curdir |endif |
| 12041 | if exists("w:netrw_explore_bufnr") |let s:explore_bufnr = w:netrw_explore_bufnr |endif |
| 12042 | if exists("w:netrw_explore_indx") |let s:explore_indx = w:netrw_explore_indx |endif |
| 12043 | if exists("w:netrw_explore_line") |let s:explore_line = w:netrw_explore_line |endif |
| 12044 | if exists("w:netrw_explore_listlen")|let s:explore_listlen = w:netrw_explore_listlen|endif |
| 12045 | if exists("w:netrw_explore_list") |let s:explore_list = w:netrw_explore_list |endif |
| 12046 | if exists("w:netrw_explore_mtchcnt")|let s:explore_mtchcnt = w:netrw_explore_mtchcnt|endif |
| 12047 | if exists("w:netrw_fpl") |let s:fpl = w:netrw_fpl |endif |
| 12048 | if exists("w:netrw_hline") |let s:hline = w:netrw_hline |endif |
| 12049 | if exists("w:netrw_line") |let s:line = w:netrw_line |endif |
| 12050 | if exists("w:netrw_liststyle") |let s:liststyle = w:netrw_liststyle |endif |
| 12051 | if exists("w:netrw_method") |let s:method = w:netrw_method |endif |
| 12052 | if exists("w:netrw_prvdir") |let s:prvdir = w:netrw_prvdir |endif |
| 12053 | if exists("w:netrw_treedict") |let s:treedict = w:netrw_treedict |endif |
| 12054 | if exists("w:netrw_treetop") |let s:treetop = w:netrw_treetop |endif |
| 12055 | if exists("w:netrw_winnr") |let s:winnr = w:netrw_winnr |endif |
| 12056 | " call Dret("s:SaveWinVars") |
| 12057 | endfun |
| 12058 | |
| 12059 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12060 | " s:SetBufWinVars: (used by NetrwBrowse() and LocalBrowseCheck()) {{{2 |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12061 | " To allow separate windows to have their own activities, such as |
| 12062 | " Explore **/pattern, several variables have been made window-oriented. |
| 12063 | " However, when the user splits a browser window (ex: ctrl-w s), these |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 12064 | " variables are not inherited by the new window. SetBufWinVars() and |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12065 | " UseBufWinVars() get around that. |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 12066 | fun! s:SetBufWinVars() |
Bram Moolenaar | 5c73622 | 2010-01-06 20:54:52 +0100 | [diff] [blame] | 12067 | " call Dfunc("s:SetBufWinVars() win#".winnr()) |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 12068 | if exists("w:netrw_liststyle") |let b:netrw_liststyle = w:netrw_liststyle |endif |
| 12069 | if exists("w:netrw_bannercnt") |let b:netrw_bannercnt = w:netrw_bannercnt |endif |
| 12070 | if exists("w:netrw_method") |let b:netrw_method = w:netrw_method |endif |
| 12071 | if exists("w:netrw_prvdir") |let b:netrw_prvdir = w:netrw_prvdir |endif |
| 12072 | if exists("w:netrw_explore_indx") |let b:netrw_explore_indx = w:netrw_explore_indx |endif |
| 12073 | if exists("w:netrw_explore_listlen")|let b:netrw_explore_listlen= w:netrw_explore_listlen|endif |
| 12074 | if exists("w:netrw_explore_mtchcnt")|let b:netrw_explore_mtchcnt= w:netrw_explore_mtchcnt|endif |
| 12075 | if exists("w:netrw_explore_bufnr") |let b:netrw_explore_bufnr = w:netrw_explore_bufnr |endif |
| 12076 | if exists("w:netrw_explore_line") |let b:netrw_explore_line = w:netrw_explore_line |endif |
| 12077 | if exists("w:netrw_explore_list") |let b:netrw_explore_list = w:netrw_explore_list |endif |
| 12078 | " call Dret("s:SetBufWinVars") |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12079 | endfun |
| 12080 | |
| 12081 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12082 | " s:SetRexDir: set directory for :Rexplore {{{2 |
| 12083 | fun! s:SetRexDir(islocal,dirname) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12084 | " call Dfunc("s:SetRexDir(islocal=".a:islocal." dirname<".a:dirname.">) win#".winnr()) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12085 | let w:netrw_rexdir = a:dirname |
| 12086 | let w:netrw_rexlocal = a:islocal |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12087 | let s:rexposn_{bufnr("%")} = winsaveview() |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 12088 | " call Decho("setting w:netrw_rexdir =".w:netrw_rexdir,'~'.expand("<slnum>")) |
| 12089 | " call Decho("setting w:netrw_rexlocal=".w:netrw_rexlocal,'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12090 | " call Decho("saving posn to s:rexposn_".bufnr("%")."<".string(s:rexposn_{bufnr("%")}).">",'~'.expand("<slnum>")) |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 12091 | " call Decho("setting s:rexposn_".bufnr("%")."<".bufname("%")."> to ".string(winsaveview()),'~'.expand("<slnum>")) |
Bram Moolenaar | 97d6249 | 2012-11-15 21:28:22 +0100 | [diff] [blame] | 12092 | " call Dret("s:SetRexDir : win#".winnr()." ".(a:islocal? "local" : "remote")." dir: ".a:dirname) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12093 | endfun |
| 12094 | |
| 12095 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12096 | " s:ShowLink: used to modify thin and tree listings to show links {{{2 |
| 12097 | fun! s:ShowLink() |
| 12098 | " " call Dfunc("s:ShowLink()") |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12099 | " " call Decho("b:netrw_curdir<".(exists("b:netrw_curdir")? b:netrw_curdir : "doesn't exist").">",'~'.expand("<slnum>")) |
| 12100 | " " call Decho(printf("line#%4d: %s",line("."),getline(".")),'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12101 | if exists("b:netrw_curdir") |
| 12102 | norm! $?\a |
| 12103 | let fname = b:netrw_curdir.'/'.s:NetrwGetWord() |
| 12104 | let resname = resolve(fname) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12105 | " " call Decho("fname <".fname.">",'~'.expand("<slnum>")) |
| 12106 | " " call Decho("resname <".resname.">",'~'.expand("<slnum>")) |
| 12107 | " " call Decho("b:netrw_curdir<".b:netrw_curdir.">",'~'.expand("<slnum>")) |
| 12108 | if resname =~ '^\M'.b:netrw_curdir.'/' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12109 | let dirlen = strlen(b:netrw_curdir) |
| 12110 | let resname = strpart(resname,dirlen+1) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12111 | " " call Decho("resname<".resname."> (b:netrw_curdir elided)",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12112 | endif |
| 12113 | let modline = getline(".")."\t --> ".resname |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12114 | " " call Decho("fname <".fname.">",'~'.expand("<slnum>")) |
| 12115 | " " call Decho("modline<".modline.">",'~'.expand("<slnum>")) |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12116 | setl noro ma |
| 12117 | call setline(".",modline) |
| 12118 | setl ro noma nomod |
| 12119 | endif |
| 12120 | " " call Dret("s:ShowLink".((exists("fname")? ' : '.fname : 'n/a'))) |
| 12121 | endfun |
| 12122 | |
| 12123 | " --------------------------------------------------------------------- |
| 12124 | " s:ShowStyle: {{{2 |
| 12125 | fun! s:ShowStyle() |
| 12126 | if !exists("w:netrw_liststyle") |
| 12127 | let liststyle= g:netrw_liststyle |
| 12128 | else |
| 12129 | let liststyle= w:netrw_liststyle |
| 12130 | endif |
| 12131 | if liststyle == s:THINLIST |
| 12132 | return s:THINLIST.":thin" |
| 12133 | elseif liststyle == s:LONGLIST |
| 12134 | return s:LONGLIST.":long" |
| 12135 | elseif liststyle == s:WIDELIST |
| 12136 | return s:WIDELIST.":wide" |
| 12137 | elseif liststyle == s:TREELIST |
| 12138 | return s:TREELIST.":tree" |
| 12139 | else |
| 12140 | return 'n/a' |
| 12141 | endif |
| 12142 | endfun |
| 12143 | |
| 12144 | " --------------------------------------------------------------------- |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12145 | " s:Strlen: this function returns the length of a string, even if its using multi-byte characters. {{{2 |
| 12146 | " Solution from Nicolai Weibull, vim docs (:help strlen()), |
| 12147 | " Tony Mechelynck, and my own invention. |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12148 | fun! s:Strlen(x) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12149 | " "" call Dfunc("s:Strlen(x<".a:x."> g:Align_xstrlen=".g:Align_xstrlen.")") |
| 12150 | |
| 12151 | if v:version >= 703 && exists("*strdisplaywidth") |
| 12152 | let ret= strdisplaywidth(a:x) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12153 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12154 | elseif type(g:Align_xstrlen) == 1 |
| 12155 | " allow user to specify a function to compute the string length (ie. let g:Align_xstrlen="mystrlenfunc") |
| 12156 | exe "let ret= ".g:Align_xstrlen."('".substitute(a:x,"'","''","g")."')" |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12157 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12158 | elseif g:Align_xstrlen == 1 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12159 | " number of codepoints (Latin a + combining circumflex is two codepoints) |
| 12160 | " (comment from TM, solution from NW) |
| 12161 | let ret= strlen(substitute(a:x,'.','c','g')) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12162 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12163 | elseif g:Align_xstrlen == 2 |
| 12164 | " number of spacing codepoints (Latin a + combining circumflex is one spacing |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12165 | " codepoint; a hard tab is one; wide and narrow CJK are one each; etc.) |
| 12166 | " (comment from TM, solution from TM) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12167 | let ret=strlen(substitute(a:x, '.\Z', 'x', 'g')) |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12168 | |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12169 | elseif g:Align_xstrlen == 3 |
| 12170 | " virtual length (counting, for instance, tabs as anything between 1 and |
| 12171 | " 'tabstop', wide CJK as 2 rather than 1, Arabic alif as zero when immediately |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12172 | " preceded by lam, one otherwise, etc.) |
| 12173 | " (comment from TM, solution from me) |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12174 | let modkeep= &l:mod |
| 12175 | exe "norm! o\<esc>" |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12176 | call setline(line("."),a:x) |
| 12177 | let ret= virtcol("$") - 1 |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12178 | d |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12179 | NetrwKeepj norm! k |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12180 | let &l:mod= modkeep |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12181 | |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12182 | else |
| 12183 | " at least give a decent default |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12184 | let ret= strlen(a:x) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12185 | endif |
Bram Moolenaar | 8d04317 | 2014-01-23 14:24:41 +0100 | [diff] [blame] | 12186 | " "" call Dret("s:Strlen ".ret) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12187 | return ret |
| 12188 | endfun |
| 12189 | |
| 12190 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12191 | " s:ShellEscape: shellescape(), or special windows handling {{{2 |
| 12192 | fun! s:ShellEscape(s, ...) |
| 12193 | if (has('win32') || has('win64')) && $SHELL == '' && &shellslash |
| 12194 | return printf('"%s"', substitute(a:s, '"', '""', 'g')) |
| 12195 | endif |
| 12196 | let f = a:0 > 0 ? a:1 : 0 |
| 12197 | return shellescape(a:s, f) |
| 12198 | endfun |
| 12199 | |
| 12200 | " --------------------------------------------------------------------- |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12201 | " s:TreeListMove: supports [[, ]], [], and ][ in tree mode {{{2 |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12202 | fun! s:TreeListMove(dir) |
| 12203 | " call Dfunc("s:TreeListMove(dir<".a:dir.">)") |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12204 | let curline = getline('.') |
| 12205 | let prvline = (line(".") > 1)? getline(line(".")-1) : '' |
| 12206 | let nxtline = (line(".") < line("$"))? getline(line(".")+1) : '' |
| 12207 | let curindent = substitute(getline('.'),'^\(\%('.s:treedepthstring.'\)*\)[^'.s:treedepthstring.'].\{-}$','\1','e') |
| 12208 | let indentm1 = substitute(curindent,'^'.s:treedepthstring,'','') |
| 12209 | let treedepthchr = substitute(s:treedepthstring,' ','','g') |
| 12210 | let stopline = exists("w:netrw_bannercnt")? w:netrw_bannercnt : 1 |
| 12211 | " call Decho("prvline <".prvline."> #".(line(".")-1), '~'.expand("<slnum>")) |
| 12212 | " call Decho("curline <".curline."> #".line(".") , '~'.expand("<slnum>")) |
| 12213 | " call Decho("nxtline <".nxtline."> #".(line(".")+1), '~'.expand("<slnum>")) |
| 12214 | " call Decho("curindent<".curindent.">" , '~'.expand("<slnum>")) |
| 12215 | " call Decho("indentm1 <".indentm1.">" , '~'.expand("<slnum>")) |
| 12216 | " COMBAK : need to handle when on a directory |
| 12217 | " COMBAK : need to handle ]] and ][. In general, needs work!!! |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12218 | if curline !~ '/$' |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12219 | if a:dir == '[[' && prvline != '' |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12220 | NetrwKeepj norm! 0 |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12221 | let nl = search('^'.indentm1.'\%('.s:treedepthstring.'\)\@!','bWe',stopline) " search backwards |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12222 | " call Decho("regfile srch back: ".nl,'~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12223 | elseif a:dir == '[]' && nxtline != '' |
| 12224 | NetrwKeepj norm! 0 |
Bram Moolenaar | aa3b15d | 2016-04-21 08:53:19 +0200 | [diff] [blame] | 12225 | " call Decho('srchpat<'.'^\%('.curindent.'\)\@!'.'>','~'.expand("<slnum>")) |
Bram Moolenaar | e0fa374 | 2016-02-20 15:47:01 +0100 | [diff] [blame] | 12226 | let nl = search('^\%('.curindent.'\)\@!','We') " search forwards |
| 12227 | if nl != 0 |
| 12228 | NetrwKeepj norm! k |
| 12229 | else |
| 12230 | NetrwKeepj norm! G |
| 12231 | endif |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12232 | " call Decho("regfile srch fwd: ".nl,'~'.expand("<slnum>")) |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12233 | endif |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12234 | endif |
| 12235 | |
| 12236 | " call Dret("s:TreeListMove") |
| 12237 | endfun |
| 12238 | |
| 12239 | " --------------------------------------------------------------------- |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 12240 | " s:UpdateBuffersMenu: does emenu Buffers.Refresh (but due to locale, the menu item may not be called that) {{{2 |
| 12241 | " The Buffers.Refresh menu calls s:BMShow(); unfortunately, that means that that function |
| 12242 | " can't be called except via emenu. But due to locale, that menu line may not be called |
| 12243 | " Buffers.Refresh; hence, s:NetrwBMShow() utilizes a "cheat" to call that function anyway. |
| 12244 | fun! s:UpdateBuffersMenu() |
| 12245 | " call Dfunc("s:UpdateBuffersMenu()") |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 12246 | if has("gui") && has("menu") && has("gui_running") && &go =~# 'm' && g:netrw_menu |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 12247 | try |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 12248 | sil emenu Buffers.Refresh\ menu |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 12249 | catch /^Vim\%((\a\+)\)\=:E/ |
| 12250 | let v:errmsg= "" |
Bram Moolenaar | 8feef4f | 2015-01-07 16:57:10 +0100 | [diff] [blame] | 12251 | sil NetrwKeepj call s:NetrwBMShow() |
Bram Moolenaar | c236c16 | 2008-07-13 17:41:49 +0000 | [diff] [blame] | 12252 | endtry |
| 12253 | endif |
| 12254 | " call Dret("s:UpdateBuffersMenu") |
| 12255 | endfun |
| 12256 | |
| 12257 | " --------------------------------------------------------------------- |
Bram Moolenaar | 446cb83 | 2008-06-24 21:56:24 +0000 | [diff] [blame] | 12258 | " s:UseBufWinVars: (used by NetrwBrowse() and LocalBrowseCheck() {{{2 |
Bram Moolenaar | adc2182 | 2011-04-01 18:03:16 +0200 | [diff] [blame] | 12259 | " Matching function to s:SetBufWinVars() |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12260 | fun! s:UseBufWinVars() |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 12261 | " call Dfunc("s:UseBufWinVars()") |
| 12262 | if exists("b:netrw_liststyle") && !exists("w:netrw_liststyle") |let w:netrw_liststyle = b:netrw_liststyle |endif |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12263 | if exists("b:netrw_bannercnt") && !exists("w:netrw_bannercnt") |let w:netrw_bannercnt = b:netrw_bannercnt |endif |
| 12264 | if exists("b:netrw_method") && !exists("w:netrw_method") |let w:netrw_method = b:netrw_method |endif |
| 12265 | if exists("b:netrw_prvdir") && !exists("w:netrw_prvdir") |let w:netrw_prvdir = b:netrw_prvdir |endif |
| 12266 | if exists("b:netrw_explore_indx") && !exists("w:netrw_explore_indx") |let w:netrw_explore_indx = b:netrw_explore_indx |endif |
| 12267 | if exists("b:netrw_explore_listlen") && !exists("w:netrw_explore_listlen")|let w:netrw_explore_listlen = b:netrw_explore_listlen|endif |
| 12268 | if exists("b:netrw_explore_mtchcnt") && !exists("w:netrw_explore_mtchcnt")|let w:netrw_explore_mtchcnt = b:netrw_explore_mtchcnt|endif |
| 12269 | if exists("b:netrw_explore_bufnr") && !exists("w:netrw_explore_bufnr") |let w:netrw_explore_bufnr = b:netrw_explore_bufnr |endif |
| 12270 | if exists("b:netrw_explore_line") && !exists("w:netrw_explore_line") |let w:netrw_explore_line = b:netrw_explore_line |endif |
| 12271 | if exists("b:netrw_explore_list") && !exists("w:netrw_explore_list") |let w:netrw_explore_list = b:netrw_explore_list |endif |
Bram Moolenaar | 9964e46 | 2007-05-05 17:54:07 +0000 | [diff] [blame] | 12272 | " call Dret("s:UseBufWinVars") |
Bram Moolenaar | 90cfdbe | 2005-08-12 19:59:19 +0000 | [diff] [blame] | 12273 | endfun |
| 12274 | |
Bram Moolenaar | 1afcace | 2005-11-25 19:54:28 +0000 | [diff] [blame] | 12275 | " --------------------------------------------------------------------- |
Bram Moolenaar | a0f849e | 2015-10-30 14:37:44 +0100 | [diff] [blame] | 12276 | " s:UserMaps: supports user-defined UserMaps {{{2 |
| 12277 | " * calls a user-supplied funcref(islocal,curdir) |
| 12278 | " * interprets result |
| 12279 | " See netrw#UserMaps() |
| 12280 | fun! s:UserMaps(islocal,funcname) |
| 12281 | " call Dfunc("s:UserMaps(islocal=".a:islocal.",funcname<".a:funcname.">)") |
| 12282 | |
| 12283 | if !exists("b:netrw_curdir") |
| 12284 | let b:netrw_curdir= getcwd() |
| 12285 | endif |
| 12286 | let Funcref = function(a:funcname) |
| 12287 | let result = Funcref(a:islocal) |
| 12288 | |
| 12289 | if type(result) == 1 |
| 12290 | " if result from user's funcref is a string... |
| 12291 | " call Decho("result string from user funcref<".result.">",'~'.expand("<slnum>")) |
| 12292 | if result == "refresh" |
| 12293 | " call Decho("refreshing display",'~'.expand("<slnum>")) |
| 12294 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 12295 | elseif result != "" |
| 12296 | " call Decho("executing result<".result.">",'~'.expand("<slnum>")) |
| 12297 | exe result |
| 12298 | endif |
| 12299 | |
| 12300 | elseif type(result) == 3 |
| 12301 | " if result from user's funcref is a List... |
| 12302 | " call Decho("result List from user funcref<".string(result).">",'~'.expand("<slnum>")) |
| 12303 | for action in result |
| 12304 | if action == "refresh" |
| 12305 | " call Decho("refreshing display",'~'.expand("<slnum>")) |
| 12306 | call s:NetrwRefresh(a:islocal,s:NetrwBrowseChgDir(a:islocal,'./')) |
| 12307 | elseif action != "" |
| 12308 | " call Decho("executing action<".action.">",'~'.expand("<slnum>")) |
| 12309 | exe action |
| 12310 | endif |
| 12311 | endfor |
| 12312 | endif |
| 12313 | |
| 12314 | " call Dret("s:UserMaps") |
| 12315 | endfun |
| 12316 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12317 | " ========================== |
Bram Moolenaar | e6ae622 | 2013-05-21 21:01:10 +0200 | [diff] [blame] | 12318 | " Settings Restoration: {{{1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12319 | " ========================== |
Bram Moolenaar | 83bab71 | 2005-08-01 21:58:57 +0000 | [diff] [blame] | 12320 | let &cpo= s:keepcpo |
| 12321 | unlet s:keepcpo |
Bram Moolenaar | 5b8d8fd | 2005-08-16 23:01:50 +0000 | [diff] [blame] | 12322 | |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12323 | " =============== |
Bram Moolenaar | 83bab71 | 2005-08-01 21:58:57 +0000 | [diff] [blame] | 12324 | " Modelines: {{{1 |
Bram Moolenaar | b0d45e7 | 2017-11-05 18:19:24 +0100 | [diff] [blame] | 12325 | " =============== |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 12326 | " vim:ts=8 fdm=marker |