Rick/fichiersvim
Archived
1
0
Fork 0
Code Activity
This repository has been archived on 2023-08-14. You can view files and clone it, but cannot push or open issues or pull requests.
fichiersvim/plugin/utl.vim

1847 lines
66 KiB
VimL
Raw Blame History

" ------------------------------------------------------------------------------
" File: plugin/utl.vim - Universal Text Linking -
" URL based Hyperlinking for plain text
" Author: Stefan Bittner <stb@bf-consulting.de>
" Maintainer: Stefan Bittner <stb@bf-consulting.de>
"
" Licence: This program is free software; you can redistribute it and/or
" modify it under the terms of the GNU General Public License.
" See http://www.gnu.org/copyleft/gpl.txt
" This program is distributed in the hope that it will be
" useful, but WITHOUT ANY WARRANTY; without even the implied
" warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
"
" Version: 3.0a ALPHA
"
" Docs: for online help type: :help utl-plugin
"
" Files: The Utl plugin consists of the following files:
" plugin/{utl.vim,utl_scm.vim,utl_uri.vim,utl_rc.vim}
" doc/utl_usr.txt
"
" History:
" 1.0 2001-04-26
" First release for vim5 under the name thlnk.vim
" 1.1 2002-05-07
" As plugin for vim6 with heavily revised documentation and homepage
" 1.2 2002-06-14
" Two bug fixes, better error messages, largely enhanced documentation
" 1.2.1 2002-06-15
" Bug fix. Better 'ff' setting for distribution files
" --- Renamed plugin from Thlnk to Utl ---
" 2.0 2005-03-22
" Configurable scheme and media type handlers, syntax
" highlighting, naked URL support, #tn as default, heuristic
" support and other new features. See ../doc/utl_usr.txt#utl-changes
" 3.0a ALPHA 2008-07-31
" New : Generic media type handler, Mail protocol, Copy Link/
" Filename support, Foot-References [], Transparent editing of
" share files, Tracing, Enhanced scheme handler interface,
" Changed : User Interface with command :Utl, variable naming.
" Bug fixes.
" ------------------------------------------------------------------------------
if exists("loaded_utl") || &cp
finish
endif
let loaded_utl = "3.0a"
if v:version < 700
echohl ErrorMsg
echo "Error: You need Vim version 7.0 or later for utl.vim version ".g:loaded_utl
echohl None
finish
endif
let s:save_cpo = &cpo
set cpo&vim
let g:utl__file = expand("<sfile>")
"--- Utl User Interface [
" (:Utl not as "command! to not override a possible user command of this name.
" Fails with an error in this case.)
command -complete=custom,s:completeArgs -range -nargs=* Utl call Utl(<f-args>)
"-------------------------------------------------------------------------------
" Intended as command line completion function called back by command :Utl.
" See vimhelp:command-completion-custom.
" Based on the command line provided by user input so far it returns a \n
" separated line of items, which Vim then uses for presenting completion
" suggestions to the user.
" Also works if abbreviations ( see #r=cmd_abbreviations ) appear in cmdLine
fu! s:completeArgs(dummy_argLead, cmdLine, dummy_cursorPos)
" Split cmdLine to figure out how many arguments have been provided by user
" so far. If Using argument keepempty=1 for split will provide empty last
" arg in case of a new arg is about to begin or an non empty last argument
" in case of an incomplete last argument. So can just remove the last arg.
let utlArgs=split(a:cmdLine, '\s\+', 1)
call remove(utlArgs, -1)
" 1st arg to complete
if len(utlArgs)==1
return "openLink\ncopyFileName\ncopyLink\nhelp"
endif
let utlArgs[1] = s:abbr2longArg(utlArgs[1])
" 2nd arg to complete
if len(utlArgs)==2
if utlArgs[1]=='openLink' || utlArgs[1]=='copyFileName' || utlArgs[1]=='copyLink'
if len(utlArgs)==2
return "underCursor\nvisual\ncurrentFile\n_your_URL_here"
endif
elseif utlArgs[1]=='help'
if len(utlArgs)==2
return "manual\ncommands"
endif
endif
" config
return ''
endif
" 3rd argument to complete
if len(utlArgs)==3
if utlArgs[1]=='openLink'
return "edit\nsplit\nvsplit\ntabedit\nview\nread"
elseif utlArgs[1]=='copyFileName'
return "native\nslash\nbackSlash"
endif
return ''
endif
return ''
endfun
" [id=cmd_reference]
"-------------------------------------------------------------------------------
" Table of :Utl commands/arguments. The [xxx] are default values and can
" be omitted. ( The table is implemented at #r=Utl )
"
" arg# 1 2 3
"
" :Utl [openLink] [underCursor] [edit]
" :Utl visual split
" :Utl currentFile vsplit
" :Utl <my_url> tabedit
" :Utl view
" :Utl read
"
" :Utl copyLink [underCursor]
" :Utl visual
" :Utl currentFile
" :Utl <my_url>
"
" :Utl copyFileName [underCursor] [native]
" :Utl currentFile backSlash
" :Utl Visual slash
" :Utl <my_url>
"
" :Utl help [manual]
" :Utl commands
" [id=cmd_abbreviations]
"-------------------------------------------------------------------------------
" Supported abbreviations of arguments to :Utl command.
" Abbreviation conventions are:
" - More than one abbreviation per argument is possible
" - All uppercase letter of a camel word as lower letters (copyFileName -> cfn)
" - Fewer and fewer uppercase letters as long as still unique
" (cfn -> cf. But not c since else clash with copyLink)
" - The shortest (camel sub-)word beginning until unique
" (view and vsplit -> vi and vs resp.)
"
" (More keys (=abbreviations) can be added to the dictionaries without further
" change as long as the values are valid long arguments.)
"
let s:d1= { 'o': 'openLink', 'ol': 'openLink', 'cl': 'copyLink', 'cf': 'copyFileName', 'cfn': 'copyFileName', 'h': 'help' }
let s:d21={ 'u': 'underCursor', 'uc': 'underCursor', 'v': 'visual', 'c': 'currentFile', 'cf': 'currentFile' }
let s:d22={ 'm': 'manual', 'c': 'commands' }
let s:d31={ 'e': 'edit', 's': 'split', 'vs': 'vsplit', 't': 'tabedit', 'te': 'tabedit', 'vi': 'view', 'r': 'read' }
let s:d32={ 'n': 'native', 'b': 'backSlash', 'bs': 'backSlash', 's': 'slash' }
"-------------------------------------------------------------------------------
" Convert possible :Utl arg abbreviation for last arg into long arg. The args
" before are the :Utl args provided so far in long form.
"
" Args: Utl command arguments according #r=cmd_reference, where the last
" can be abbreviated.
" Returns: Last arg converted into long arg
"
" Collaboration:
"
" Example: s:abbr2longArg('copyFileName', 'underCursor', 's')
" returns 'slash'
"
fu! s:abbr2longArg(...)
if ! exists('a:2')
return s:utilLookup(s:d1, a:1)
elseif ! exists('a:3')
if a:1=='openLink'|| a:1=='copyLink'|| a:1=='copyFileName'
return s:utilLookup(s:d21, a:2)
elseif a:1=='help'
return s:utilLookup(s:d22, a:2)
endif
else
if a:1=='openLink'
return s:utilLookup(s:d31, a:3)
elseif a:1 == 'copyFileName'
return s:utilLookup(s:d32, a:3)
endif
endif
endfu
"-------------------------------------------------------------------------------
" Lookup 'key' in 'dict'. If defined return its value else return the 'key'
" itself
fu! s:utilLookup(dict,key)
if has_key(a:dict, a:key)
return a:dict[a:key]
endif
return a:key
endfu
"----------------------------------------------------------id=Utl---------------
" Central Utl.vim function. Normally invoked by :Utl command
" args: Same as command :Utl (but quoted), see #r=cmd_reference
"
" Example: call Utl('openLink','http://www.vim.org','split')
"
fu! Utl(...)
call Utl_trace("- start function Utl()",1,1)
if exists('a:1') | let cmd=s:abbr2longArg(a:1) | else | let cmd='openLink' | endif
call Utl_trace("- arg1 (cmd) provided or by default = `".cmd."'")
if cmd == 'openLink'
if exists('a:2') | let operand=s:abbr2longArg(cmd,a:2) | else | let operand='underCursor' | endif
call Utl_trace("- arg2 (operand) provided or by default = `".operand."'")
if exists('a:3') | let dispMode=s:abbr2longArg(cmd,operand,a:3) | else | let dispMode='edit' | endif
call Utl_trace("- arg3 (dispMode) provided or by default = `".dispMode."'")
if operand=='underCursor'
call s:Utl_goUrl(dispMode)
elseif operand=='visual'
let url = @*
call s:Utl_processUrl(url, dispMode)
elseif operand=='currentFile'
let url = 'file://'.Utl_utilBack2FwdSlashes( expand("%:p") )
call s:Utl_processUrl(url, dispMode)
else " the operand is the URL
call s:Utl_processUrl(operand, dispMode)
endif
elseif cmd=='copyFileName' || cmd=='copyLink'
if exists('a:2') | let operand=s:abbr2longArg(cmd,a:2) | else | let operand='underCursor' | endif
call Utl_trace("- arg2 (operand) provided or by default = `".operand."'")
let suffix=''
if cmd == 'copyFileName'
if exists('a:3') | let modifier=s:abbr2longArg(cmd,operand,a:3) | else | let modifier='native' | endif
call Utl_trace("- arg3 (modifier) provided or by default = `".modifier."'")
let suffix='_'.modifier
endif
if operand=='underCursor'
call s:Utl_goUrl(cmd.suffix)
elseif operand=='visual'
let url = @*
call s:Utl_processUrl(url, cmd.suffix)
elseif operand=='currentFile'
let url = 'file://'.Utl_utilBack2FwdSlashes( expand("%:p") )
call s:Utl_processUrl(url, cmd.suffix)
else " the operand is the URL
call Utl_trace("- `".operand."' (arg2) is not a keyword. So is directly taken as an URL")
call s:Utl_processUrl(operand, cmd.suffix)
endif
elseif cmd == 'help'
if exists('a:2') | let operand=s:abbr2longArg(cmd,a:2) | else | let operand='manual' | endif
call Utl_trace("- arg2 (operand) provided or by default = `".operand."'\n") " CR054_extra_nl
if operand=='manual'
help utl_usr.txt
elseif operand=='commands'
call Utl('openLink', 'file://'.Utl_utilBack2FwdSlashes(expand(g:utl__file)).'#r=cmd_reference', 'sview')
else
echohl ErrorMsg | echo "invalid argument: `".operand."'" | echohl None
endif
else
echohl ErrorMsg | echo "invalid argument: `".cmd."'" | echohl None
endif
call Utl_trace("- end function Utl()",1,-1)
endfu
"]
"--- Set unset Utl options to defaults (id=options) [
if ! exists("utl_opt_verbose")
let utl_opt_verbose=0
endif
if ! exists("utl_opt_highlight_urls")
let utl_opt_highlight_urls='yes'
endif
"]
"--- Suggested mappings for most frequent commands [id=suggested_mappings] [
"
" nmap <unique> <Leader>ge :Utl openLink underCursor edit<CR>
" nmap <unique> <Leader>gu :Utl openLink underCursor edit<CR>
" nmap <unique> <Leader>gE :Utl openLink underCursor split<CR>
" nmap <unique> <Leader>gS :Utl openLink underCursor vsplit<CR>
" nmap <unique> <Leader>gt :Utl openLink underCursor tabedit<CR>
" nmap <unique> <Leader>gv :Utl openLink underCursor view<CR>
" nmap <unique> <Leader>gr :Utl openLink underCursor read<CR>
"
" [id=suggested_mappings_visual]
" vmap <unique> <Leader>ge "*y:Utl openLink visual edit<CR>
" vmap <unique> <Leader>gu "*y:Utl openLink visual edit<CR>
" vmap <unique> <Leader>gE "*y:Utl openLink visual split<CR>
" vmap <unique> <Leader>gS "*y:Utl openLink visual vsplit<CR>
" vmap <unique> <Leader>gt "*y:Utl openLink visual tabedit<CR>
" vmap <unique> <Leader>gv "*y:Utl openLink visual view<CR>
" vmap <unique> <Leader>gr "*y:Utl openLink visual read<CR>
"
"
" nmap <unique> <Leader>cfn :Utl copyFileName underCursor native<CR>
" nmap <unique> <Leader>cfs :Utl copyFileName underCursor slash<CR>
" nmap <unique> <Leader>cfb :Utl copyFileName underCursor backSlash<CR>
"
" vmap <unique> <Leader>cfn "*y:Utl copyFileName visual native<CR>
" vmap <unique> <Leader>cfs "*y:Utl copyFileName visual slash<CR>
" vmap <unique> <Leader>cfb "*y:Utl copyFileName visual backSlash<CR>
"
"
" nmap <unique> <Leader>cl :Utl copyLink underCursor<CR>
"
" vmap <unique> <Leader>cl "*y:Utl copyLink visual<CR>
"
"]
let s:utl_esccmdspecial = '%#' " keep equal to utl_scm.vim#__esc
" isfname adapted to URI Reference characters
let s:isuriref="@,48-57,#,;,/,?,:,@-@,&,=,+,$,,,-,_,.,!,~,*,',(,),%"
"----------------------------------------------------------id=thl_gourl---------
" Process URL (or read: URI, if you like---Utl isn't exact there) under
" cursor: searches for something like <URL:myUrl> or <A HREF="myUrl"> (depending
" on the context), extracts myUrl, an processes that Url (e.g. retrieves the
" document and displays it).
"
" - Arg dispMode -> see <URL:#r=dispMode>
"
fu! s:Utl_goUrl(dispMode)
call Utl_trace("- start processing (dispMode=".a:dispMode.")",1,1)
let url = Utl_getUrlUnderCursor()
if url == ''
let v:errmsg = "No URL under Cursor"
echohl ErrorMsg | echo v:errmsg | echohl None
else
call s:Utl_processUrl(url, a:dispMode)
endif
call Utl_trace("- end processing.",1,-1)
endfu
"-------------------------------------------------------------------------------
" Tries to extract an URL in current buffer at current cursor position.
"
" Returns: URL under cursor if any, else ''
"
fu! Utl_getUrlUnderCursor()
call Utl_trace("- start getting URL under cursor",1,1)
let line = getline('.')
let icurs = col('.') - 1 " `Index-Cursor'
call Utl_trace("- first try: checking for URL with embedding like <url:xxx> in current line...",1,1)
let url = s:Utl_extractUrlByPattern(line, icurs, '')
if url=='<undef>'
call Utl_trace("- ...no",1,-1)
call Utl_trace("- retry: checking for embedded URL spanning over range of max 5 lines...",1,1)
let lineno = line('.')
" (lineno-1/2 can be negative -> getline gives empty string -> ok)
let line = getline(lineno-2) . "\n" . getline(lineno-1) . "\n" .
\ getline(lineno) . "\n" .
\ getline(lineno+1) . "\n" . getline(lineno+2)
" `Index of Cursor'
" (icurs off by +2 because of 2 \n's, plus -1 because col() starts at 1 = +1)
let icurs = strlen(getline(lineno-2)) + strlen(getline(lineno-1)) + col('.') +1
let url = s:Utl_extractUrlByPattern(line, icurs, '')
endif
if url=='<undef>'
call Utl_trace("- ...no", 1, -1)
call Utl_trace("- retry: checking if [ ] style reference...", 1, 1)
if stridx(line, '[') != -1
let isfname_save = &isfname | let &isfname = s:isuriref " ([)
let pat = '\(\(\[[A-Z0-9_]\{-}\]\)\(#\f*\)*\)' " &isfname here in \f
let url = s:Utl_extractUrlByPattern(line, icurs, pat)
let &isfname = isfname_save " (])
" remove trailing punctuation characters if any
if url!='<undef>'
call Utl_trace("- removing trailing punctuation chars from URL if any")
let url = substitute(url, '[.,:;!?]$', '', '')
endif
endif
endif
if url=='<undef>'
call Utl_trace("- ...no", 1,-1)
call Utl_trace("- retry: checking for unembedded URL under cursor...", 1,1)
" Take <cfile> as URL. But adapt isfname to match all allowed URI Reference characters
let isfname_save = &isfname | let &isfname = s:isuriref " ([)
let url = expand("<cfile>")
let &isfname = isfname_save " (])
endif
if url!=''
call Utl_trace("- ...yes, URL found: `".url."'", 1,-1)
else
call Utl_trace("- ...no", 1,-1)
endif
call Utl_trace("- end getting URL under cursor.",1,-1)
return url
endfu
"--------------------------------------------------------id=thl_curl------------
" `Utl_extractUrlByPattern' - Extracts embedded URLs from 'linestr':
" Extracts URL from given string 'linestr' (if any) at position 'icurs' (first
" character in linestr is 0). When there is no URL or icurs does not hit the
" URL (i.e. 'URL is not under cursor') returns '<undef>'. Note, that there can
" be more than one URL in linestr. Linestr may contain newlines (i.e. supports
" multiline URLs).
"
" 'pat' argument:
" Embedded URL means, that the URL is surrounded by some tag or characters
" to allow for safe parsing, for instance '<url:'...'>'. This regexp pattern
" has to specify a group \(...\) by which defines the URL.
" Example : '<url:\([^<]\{-}\)>'. If an empty pattern '' is given, default
" patterns apply (see code below).
"
" Examples:
" :echo s:Utl_extractUrlByPattern('Two Urls <URL:/foo/bar> in this <URL:/f/b> line', 35, '')
" returns `/f/b'
"
" :echo s:Utl_extractUrlByPattern('Two Urls <URL:/foo/bar> in this <URL:/f/b> line', 28, '')
" returns `<undef>'
"
" :echo s:Utl_extractUrlByPattern('Another embedding here <foo bar>', 27, '')
" returns `foo bar'
"
" Details:
" - The URL embedding (or if embedding at all) depends on the context: HTML
" has different embedding than a txt file.
" - Non HTML embeddings are of the following form: <URL:...>, <LNK:...> or
" <...>
" - Returns `<undef>' if `no link under cursor'. (Note that cannot cause
" problems because `<' is not a valid URI character)
" - Empty Urls are legal, e.g. <URL:>
" - `Under cursor' is like with vim's gf-command: icurs may also point to
" whitespace before the cursor. (Also pointing to the embedding characters
" is valid.)
"
fu! s:Utl_extractUrlByPattern(linestr, icurs, pat)
let pat = a:pat
call Utl_trace("- start extracting URL by pattern `".pat."'",1,1)
if pat == ''
call Utl_trace("- pattern is <undef>, determine based on file type")
if &ft == 'html'
let embedType = 'html'
else
let embedType = 'txt'
endif
" (pat has to have the Url in first \(...\) because ({) )
if embedType == 'html'
call Utl_trace("- file type is 'html'")
" Html-Pattern:
" - can have other attributes in <A>, like
" <A TITLE="foo" HREF="#bar"> (before and/or behind HREF)
" - can have Whitespace embedding the `=' like
" <A HREF = "#bar">
" Note: Url must be surrounded by `"'. But that should not be mandatory...
" Regexp-Guru please help!
let pat = '<A.\{-}HREF\s*=\s*"\(.\{-}\)".\{-}>'
else
call Utl_trace("- file type is not 'html', so use generic pattern")
" Allow different embeddings: <URL:myUrl>, <myUrl>.
" Plus <LNK:myUrl> for backward compatibility utl-1.0 and future
" extension.
" ( % in pattern means that this group doesn't count as \1 )
let pat = '<\%(URL:\|LNK:\|\)\([^<]\{-}\)>'
endif
call Utl_trace("- will use pattern `".pat."'")
endif
let linestr = a:linestr
let icurs = a:icurs
" do match() and matchend() ic (i.e. allow url: urL: Url: lnk: lnk: LnK:
" <a href= <A HREF= ...)
let saveIgnorecase = &ignorecase | set ignorecase " ([)
call Utl_trace("- now try to extract URL from given string using this pattern")
while 1
" (A so called literal \n here (and elsewhere), see
" <URL:vimhelp:expr-==#^since a string>.
" \_s* can't be used because a string is considered a single line.)
let ibeg = match(linestr, "[ \\t \n]*".pat)
if ibeg == -1 || ibeg > icurs
let curl = '<undef>'
break
else
" matchstart before cursor or same col as cursor,
" look if matchend is ok (i.e. after or equal cursor)
let iend = matchend(linestr, "[ \\t \n]*".pat) -1
if iend >= icurs
" extract the URL itself from embedding
let curl = substitute(linestr, '^.\{-}'.pat.'.*', '\1', '') " (})
break
else
" match was before cursor. Check for a second URL in linestr;
" redo with linestr = `subline' behind the match
let linestr = strpart(linestr, iend+1, 9999)
let icurs = icurs-iend-1
continue
endif
endif
endwhile
let &ignorecase = saveIgnorecase " (])
call Utl_trace("- end extracting URL by pattern, returning URL=`".curl."'",1,-1)
return curl
endfu
"-------------------------------------------------------------------------------
" Switch syntax highlighting for URLs on or off. Depending on the config
" variable g:utl_opt_highlight_urls
fu! s:Utl_setHighl()
if g:utl_opt_highlight_urls ==? 'yes'
augroup utl_highl
au!
au BufWinEnter * syn case ignore
" [id=highl_custom]
" Highlighting of URL surrounding `<url' and `>' " [id=highl_surround]
"au BufWinEnter * hi link UtlTag Identifier " as of Utl v2.0
"au BufWinEnter * hi link UtlTag Ignore " `<url:' and '>' invisible like | | in Vim help
"au BufWinEnter * hi link UtlTag PreProc
" Highlighting of URL itself (what is inside `<url' and '>' " [id=highl_inside]
" Some fixed colors ( not changing with :colorscheme, but all underlined )
"au BufWinEnter * hi UtlUrl ctermfg=LightBlue guifg=LightBlue cterm=underline gui=underline term=reverse
"au BufWinEnter * hi UtlUrl ctermfg=Blue guifg=Blue cterm=underline gui=underline term=reverse
"au BufWinEnter * hi UtlUrl ctermfg=Cyan guifg=Cyan cterm=underline gui=underline term=reverse
" Some Standard group names (see <url:vimhelp:group-name>)
"au BufWinEnter * hi link UtlUrl Tag
"au BufWinEnter * hi link UtlUrl Constant
au BufWinEnter * hi link UtlUrl Underlined
au BufWinEnter * syn region UtlUrl matchgroup=UtlTag start="<URL:" end=">" containedin=ALL
au BufWinEnter * syn region UtlUrl matchgroup=UtlTag start="<LNK:" end=">" containedin=ALL
au BufWinEnter utl*.vim hi link UtlTrace Comment
au BufWinEnter utl*.vim syn region UtlTrace matchgroup=UtlTrace start="call Utl_trace" end=")" containedin=ALL
au BufWinEnter * syn case match
augroup END
else
augroup utl_highl
au!
augroup END
augroup! utl_highl
" Clear for current buffer to make turn-off instantaneously visible.
" ... but does not seem to work everywhere.
if hlexists('UtlTag')
syntax clear UtlTag
endif
if hlexists('UtlUrl')
syntax clear UtlTag
endif
if hlexists('UtlTrace')
syntax clear UtlTrace
endif
endif
endfu
call s:Utl_setHighl()
"-------------------------------------------------------------------------------
" Process given Url.
"
" Processing means: retrieve or address or load or switch-to or query or
" whatever the resource given by `url'.
" When succesful, then a local file will (not necessarly) exist, and
" is displayed by vim. Or is displayed by a helper application (e.g.
" when the Url identifies an image). Often the local file is cache
" file created ad hoc (e.g. in case of network retrieve).
"
" - The uriref argument can contain line breaks. \s*\n\s* Sequences are
" collapsed. Other Whitespace is left as is (CR019, CR052).
" See also <URL:http://www.ietf.org/rfc/rfc2396.txt> under
" chapter E, Recommendations.
"
" Examples:
" call s:Utl_processUrl('file:///path/to/file.txt', 'edit')
"
" call s:Utl_processUrl('file:///usr/local/share/vim/', 'vie')
" " may call Vim's explorer
"
" call s:Utl_processUrl('http://www.vim.org', 'edit')
" " call browser on URL
"
" call s:Utl_processUrl('mailto:stb@bf-consulting.de', 'vie')
" " the local file may be the return receipt in this case
"
fu! s:Utl_processUrl(uriref, dispMode)
call Utl_trace("- start processing URL `".a:uriref."' in processing mode `".a:dispMode."'",1,1)
let urirefpu = a:uriref " uriref with newline whitespace sequences purged
" check if newline contained. Collapse \s*\n\s
if match(a:uriref, "\n") != -1
let urirefpu = substitute(a:uriref, "\\s*\n\\s*", "", "g")
call Utl_trace("- URL contains new line characters. Remove them.")
call Utl_trace(" now URL= `".urirefpu."'")
endif
let uri = UriRef_getUri(urirefpu)
let fragment = UriRef_getFragment(urirefpu)
call Utl_trace("- fragment `".fragment."' stripped from URL")
"--- Handle Same Document Reference (sdreference)
" processed as separate case, because:
" 1. No additional 'retrieval' should happen (see
" <URL:http://www.ietf.org/rfc/rfc2396.txt#4.2. Same-document>).
" 2. UtlUri_abs() does not lead to a valid absolute Url (since the base-path-
" file-component will always be discarded).
"
if uri == ''
call Utl_trace("- is a same document reference. Go directly to fragment processing (in mode 'rel')")
" m=go
normal m'
call s:Utl_processFragmentText( fragment, 'rel' )
call Utl_trace("- end processing URL",1,-1)
return
endif
call Utl_trace("- start normalize URL to an absolute URL",1,1)
let scheme = UtlUri_scheme(uri)
if scheme != '<undef>'
call Utl_trace("- scheme defined (".scheme.") - so is an absolute URL")
let absuri = uri
else " `uri' is formally no absolute URI but look for some
" heuristic, e.g. prepend 'http://' to 'www.vim.org'
call Utl_trace("- scheme undefined - so is a relative URL or a heuristic URL")
call Utl_trace("- check for some heuristics like www.foo.com -> http://www.foo.com... ",0)
let absuri = s:Utl_checkHeuristicAbsUrl(uri)
if absuri != ''
let scheme = UtlUri_scheme(absuri)
call Utl_trace("yes,") | call Utl_trace(" absolute URL constructed by heuristic is `".absuri."'")
else
call Utl_trace("no")
endif
endif
if scheme == '<undef>'
let curPath = Utl_utilBack2FwdSlashes( expand("%:p") )
if stridx(curPath, '://') != -1 " id=url_buffer (e.g. by netrw)
call Utl_trace("- buffer's name looks like an absolute URL (has substring ://)")
call Utl_trace(" so take it as base URL.")
let base = curPath
else
call Utl_trace("- try to construct a `file://' base URL from current buffer... ",0)
" No corresponding resource to curPath known. (id=nobase)
" i.e. curPath was not retrieved through Utl.
" Now just make the usual heuristic of `file://localhost/'-Url;
" assume, that the curPath is the resource itsself. If then the
" retrieve with the so generated Url is not possible, nothing
" severe happens.
if curPath == ''
call Utl_trace("not possible, give up")
let v:errmsg = "Cannot make a base URL from unnamed buffer. Edit a file and try again"
echohl ErrorMsg | echo v:errmsg | echohl None
call Utl_trace("- end normalize URL to an absolute URL",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
let base = 'file://' . curPath
call Utl_trace("done,")
endif
call Utl_trace(" base URL is `".base."'")
let scheme = UtlUri_scheme(base)
call Utl_trace("- construct absolute URL from combining base URL and relative URL")
let absuri = UtlUri_abs(uri,base)
endif
call Utl_trace("- assertion: now have absolute URL `".absuri."' with scheme `".scheme."'")
call Utl_trace("- end normalize URL to an absolute URL",1,-1)
if a:dispMode==? 'copyLink'
call Utl_trace("processing mode is `copyLink'. Copy link to clipboard")
call setreg('*', absuri)
echo "Copied `".@*."' to clipboard"
call Utl_trace("- end processing URL",1,-1)
return
endif
"--- Call the appropriate retriever (see <URL:utl_scm.vim>)
call Utl_trace("- start scheme handler processing",1,1)
" Always set a jump mark to allow get back to cursor position before
" jump (see also CR051).
" m=go id=_setj
normal m'
let cbfunc = 'Utl_AddressScheme_' . scheme
call Utl_trace("- constructing call back function name from scheme: `".cbfunc."'")
if !exists('*'.cbfunc)
let v:errmsg = "Sorry, scheme `".scheme.":' not implemented"
echohl ErrorMsg | echo v:errmsg | echohl None
call Utl_trace("- end scheme handler processing",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
call Utl_trace("- calling call back function with arguments:")
call Utl_trace(" arg 1 - absolute URL=`".absuri."'")
call Utl_trace(" arg 2 - fragment =`".fragment."'")
call Utl_trace(" arg 3 - display Mode=`".a:dispMode."'")
exe 'let ret = ' cbfunc . '("'.absuri.'", "'.fragment.'", "'.a:dispMode.'")'
call Utl_trace("- call back function `".cbfunc."' returned list:`". join(ret,',') ."'")
exe "normal \<C-L>" | " Redraw seems necessary for non GUI Vim under Unix'es
if !len(ret)
call Utl_trace("- empty list -> no further processing")
call Utl_trace("- end scheme handler processing",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
let localPath = ret[0]
let fragMode = get(ret, 1, 'abs')
call Utl_trace("- first list element (local path): `".localPath."'")
call Utl_trace("- second list element (fragment mode) or default: `".fragMode."'")
" Assertion
if stridx(localPath, '\') != -1
echohl ErrorMsg
call input("Internal Error: localPath `".localPath."' contains backslashes <RETURN>")
echohl None
endif
call Utl_trace("- assertion: a local path corresponds to URL")
call Utl_trace("- end scheme handler processing",1,-1)
let dispMode = a:dispMode
if a:dispMode == 'copyFileName_native'
if has("win32") || has("win16") || has("win64") || has("dos32") || has("dos16")
call Utl_trace("- changing dispMode `copyFileName_native' to 'copyFileName_backSlash' since under Windows")
let dispMode = 'copyFileName_backSlash'
else
call Utl_trace("- changing dispMode `copyFileName_native' to 'copyFileName_slash' since not under Windows")
let dispMode = 'copyFileName_slash'
endif
endif
if dispMode == 'copyFileName_slash'
call Utl_trace("- processing mode is `copyFileName_slash': copy file name, which corresponds to link")
call Utl_trace(" (with forward slashes) to clipboard")
call setreg('*', localPath )
echo "Copied `".@*."' to clipboard"
call Utl_trace("- end processing URL",1,-1)
return
elseif dispMode == 'copyFileName_backSlash'
call Utl_trace("- processing mode is `copyFileName_backSlash': copy file name, which corresponds to link")
call Utl_trace(" (with backslashes) to clipboard")
call setreg('*', Utl_utilFwd2BackSlashes(localPath) )
echo "Copied `".@*."' to clipboard"
call Utl_trace("- end processing URL",1,-1)
return
endif
" See if media type is defined for localPath, and if yes, whether a
" handler is defined for this media type (if not the Setup is called to
" define one). Everything else handle with the default handler
" Utl_displayFile(), which displays the document in a Vim window.
" The pseudo handler named 'VIM' is supported: Allows bypassing the media
" type handling and call default vim handling (Utl_displayFile)
" although there is a media type defined.
call Utl_trace("- start media type handler processing",1,1)
call Utl_trace("- check if there is a file-name to media-type mapping for local path")
call Utl_trace(" (hardcoded in Utl)... ",0)
let contentType = s:Utl_checkMediaType(localPath)
if contentType == ''
call Utl_trace("no. Display local path in this Vim.")
else
call Utl_trace("yes, media type is `".contentType."'.")
let slashPos = stridx(contentType, '/')
let var_s = 'g:utl_cfg_hdl_mt_' . substitute(contentType, '[-/+.]', '_', 'g')
call Utl_trace("- constructing Vim variable for specific media type handler:")
call Utl_trace(" `".var_s."'. Now check if it exists...")
if exists(var_s)
call Utl_trace(" ...exists, and will be used")
let var = var_s
else
call Utl_trace(" ...does not exist. Now check generic media type handler variable")
let var_g = 'g:utl_cfg_hdl_mt_generic'
if exists(var_g)
call Utl_trace("- Vim variable `".var_g."' does exist and will be used")
else
call Utl_trace(" Vim variable `".var_g."' does not exist either")
endif
let var = var_g
endif
if ! exists(var) " Entering setup
echohl WarningMsg
call input('No handler for media type '.contentType.' defined yet. Entering Setup now. <RETURN>')
echohl None
call s:Utl_processUrl('config:#r=utl_cfg_hdl_mt_generic', 'split') " (recursion, setup)
call Utl_trace("- end media type handler processing",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
exe 'let varVal =' . var
call Utl_trace("- Variable has value `".varVal."'")
if varVal ==? 'VIM'
call Utl_trace("- value of variable is 'VIM': display in this Vim")
else
call Utl_trace("- construct command by expanding any % conversion specifiers.")
let convSpecDict= { 'p': localPath, 'P': Utl_utilFwd2BackSlashes(localPath),
\ 'f': (fragment=="<undef>" ? "" : fragment) } " '<undef>' -> '' for external handler
exe 'let [errmsg,cmd] = Utl_utilExpandConvSpec('.var.', convSpecDict)'
if errmsg != ""
echohl ErrorMsg
echo "The content of the Utl-setup variable `".var."' is invalid and has to be fixed! Reason: `".errmsg."'"
echohl None
call Utl_trace("- end media type handler processing",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
call Utl_trace("- constructed command is: `".cmd."'")
" Escape string to be executed as a ex command (i.e. escape some
" characters from special treatment <URL:vimhelp:cmdline-special>)
" and execute the command
let escCmd = escape(cmd, s:utl_esccmdspecial)
if escCmd != cmd
call Utl_trace("- escape characters, command changes to: `".escCmd."'")
endif
call Utl_trace("- execute command with :exe")
exe escCmd
call Utl_trace("- end media type handler processing",1,-1)
call Utl_trace("- end processing URL",1,-1)
return
endif
endif
call Utl_trace("- end media type handler processing",1,-1)
if s:Utl_displayFile(localPath, dispMode)
call s:Utl_processFragmentText(fragment, fragMode)
endif
call Utl_trace("- end processing URL",1,-1)
endfu
"id=Utl_checkHeuristicAbsUrl--------------------------------------------------
"
" This function is called for every URL which is not an absolute URL.
" It should check if the URL is meant to be an absolute URL and return
" the absolute URL. E.g. www.host.domain -> http://www.host.domain.
"
" You might want to extend this function for your own special URLs
" and schemes, see #r=heur_example below
"
fu! s:Utl_checkHeuristicAbsUrl(uri)
"--- [1] -> foot:1
if match(a:uri, '^\[.\{-}\]') != -1
return substitute(a:uri, '^\[\(.\{-}\)\]', 'foot:\1', '')
"--- www.host.domain -> http://www.host.domain
elseif match(a:uri, '^www\.') != -1
return 'http://' . a:uri
"--- user@host.domain -> mailto:user@host.domain
elseif match(a:uri, '@') != -1
return 'mailto:' . a:uri
"--- :xxx -> vimscript::xxx
elseif match(a:uri, '^:') != -1
return 'vimscript:' . a:uri
" BT12084 -> BT:12084 #id=heur_example
" This is an example of a custom heuristics which I use myself. I have a
" text file which contains entries like 'BT12084' which refer to that id
" 12084 in a bug tracking database.
elseif match(a:uri, '^[PB]T\d\{4,}') != -1
return substitute(a:uri, '^\([PB]T\)\(\d\+\)', 'BT:\2', '')
endif
return ''
endfu
"------------------------------------------------------------------------------
" Escape some special characters in fileName which have special meaning
" in Vim's command line but what is not desired in URLs.
" Example: In file 'a%b.txt' the % must not be expanded to the current file.
"
" - returns: Escaped fileName
"
fu! s:Utl_escapeCmdLineSpecialChars(fileName)
" - Escape characters '#' and '%' with special meaning for Vim
" cmd-line (see <URL:vimhelp:cmdline-special> because they must have no special
" meaning in URLs.
let escFileName = escape(a:fileName, s:utl_esccmdspecial)
" - Also escape '$': Will otherwise tried to be expanded by Vim as Envvar (CR030).
" But only escape if there is an identifier character after the $ (CR053).
let escFileName = substitute(escFileName, '\$\(\I\)', '\\$\1', 'g')
" - Also escape blanks because single word needed, e.g. `:e foo bar'.
" Escape spaces only if on unix (no problem on Windows) (CR033)
if has("unix")
let escFileName = escape(escFileName, ' ')
endif
return escFileName
endfu
"-------------------------------------------------------------------------------
" Description:
" Display file `localPath' in a Vim window as determined by `dispMode'
" There is special treatment if `localPath' already loaded in a buffer and
" there is special treatment if current buffer cannot be abandoned.
" Escapes characters in localPath which have special meaning for Vim but
" which must not have special meaning in URL paths.
"
" - `dispMode' specification: (id=dispMode)
" Resembles XML-XLink's `show' attribut. Value is taken directly as Vim
" command. Examples: 'view', 'edit', 'sview', 'split', 'read', 'tabe'
"
" - localPath specification:
" . May contain any characters that the OS allows (# % $ ' ')
" Note: No percent escaping here, localPath is a file name not an URL.
" For instance %20.txt is taken as literal file name.
"
" - returns: 1 on success (a:localPath loaded), else 0
"
" - collaboration:
" . Does not explicitly set the cursor
" . Does not explicitly set the ' mark
"
" Example: :call s:Utl_displayFile('t.txt', 'split')
"
fu! s:Utl_displayFile(localPath, dispMode)
call Utl_trace("- start display file `".a:localPath."' in mode `".a:dispMode."'",1,1)
let bwnrlp = bufwinnr(a:localPath)
if bwnrlp != -1 && winnr() == bwnrlp
call Utl_trace("- file already displayed in current window")
call Utl_trace("- end display file",1,-1)
return 1
endif
if bwnrlp != -1
" localPath already displayed, but not in current window
" Just make this buffer the current window.
call Utl_trace("- file already displayed, but not in other window. Move to that window")
exe bwnrlp . "wincmd w"
else " Open file
call Utl_trace("- file not yet displayed in any window")
" Possibly alter dispMode to avoid E37 error (id=_altersa)
" If buffer cannot be <URL:vimhelp:abandon>ned, for given dispMode,
" silently change the dispMode to a corresponding split-dispMode. Want
" to avoid annoying E37 message when executing URL on modified buffer (CR024)
let dispMode = a:dispMode
if getbufvar(winbufnr(0),"&mod") && ! getbufvar(winbufnr(0),"&awa") && ! getbufvar(winbufnr(0),"&hid")
if dispMode == 'edit'
let dispMode = 'split'
call Utl_trace("- current window can probably not be quit, so silently change mode to `split'")
elseif dispMode == 'view'
let dispMode = 'sview'
call Utl_trace("- current window can probably not be quit, so silently change mode to `sview'")
endif
endif
let escLocalPath = s:Utl_escapeCmdLineSpecialChars(a:localPath)
if escLocalPath != a:localPath
call Utl_trace("- Escaped one or more characters out of #,%,$ (under Unix also blank)")
call Utl_trace(" because these would else be expanded in Vim's command line")
call Utl_trace(" File name changed to: `".escLocalPath."'")
endif
"--- Try load file or create new buffer. Then check if buffer actually
" loaded - might fail for if E325 (swap file exists) and user abort
"
let cmd = dispMode.' '.escLocalPath
call Utl_trace("- trying to load/display file with command: `".cmd."'\n") " CR054_extra_nl
exe cmd
exe "normal \<C-L>" | " Redraw seems necessary for non GUI Vim under Unix'es
if bufwinnr(escLocalPath) != winnr() " not loaded
call Utl_trace("- not loaded.")
call Utl_trace("- end display file (not successful)",1,-1)
return 0
endif
endif
call Utl_trace("- end display file (successful)",1,-1)
return 1
endfu
"----------------------------------------------------------id=utl_checkmtype----
" Possibly determines the media type (= mime type) for arg `path', e.g.
" pic.jpeg -> 'image/jpeg' and returns it. Returns an empty string if media
" type cannot be determined or is uninteresting to be determined. Uninteresting
" means: Only those media types are defined here which are of potential
" interest for being handled by some external helper program (e.g. MS Word for
" application/msword or xnview for application/jpeg).
"
" When this function returns a non empty string Utl checks if a specific media
" type handler is defined. If not Utl's setup utility is called to define one.
"
" - You may add other mediatypes. See
" <URL:ftp://ftp.iana.org/assignments/media-types/> or
" <URL:http://www.iana.org/assignments/media-types/> for the registry of
" media types. On Linux try <URL:/etc/mime.types> In general this makes only
" sense when you also supply a handler for every media type you define, see
" <URL:./utl_rc.vim#r=mediaTypeHandlers>.
"
fu! s:Utl_checkMediaType(path)
if isdirectory(a:path)
return "text/directory"
endif
let ext = fnamemodify(a:path, ":e")
let mt = ''
" MS windows oriented
if ext==?'doc' || ext==?'dot' || ext==?'wrd'
let mt = 'application/msword'
elseif ext==?'xls'
let mt = 'application/excel'
elseif ext==?'ppt'
let mt = 'application/powerpoint'
elseif ext==?'wav'
let mt = 'audio/wav'
elseif ext==?'msg'
let mt = 'application/msmsg'
elseif ext==?'avi'
let mt = 'video/x-msvideo'
" universal
elseif ext==?'dvi'
let mt = 'application/x-dvi'
elseif ext==?'pdf'
let mt = 'application/pdf'
elseif ext==?'rtf'
let mt = 'application/rtf'
elseif ext==?'ai' || ext==?'eps' || ext==?'ps'
let mt = 'application/postscript'
elseif ext==?'rtf'
let mt = 'application/rtf'
elseif ext==?'zip'
let mt = 'application/zip'
elseif ext==?'mp3' || ext==?'mp2' || ext==?'mpga'
let mt = 'audio/mpeg'
elseif ext==?'png'
let mt = 'image/png'
elseif ext==?'jpeg' || ext==?'jpg' || ext==?'jpe' || ext==?'jfif'
let mt = 'image/jpeg'
elseif ext==?'tiff' || ext==?'tif'
let mt = 'image/tiff'
elseif ext==?'gif' || ext==?'gif'
let mt = 'image/gif'
elseif ext==?'mp2' || ext==?'mpe' || ext==?'mpeg' || ext==?'mpg'
let mt = 'video/mpeg'
" id=texthtml
elseif ext==?'html' || ext==?'htm'
let mt = 'text/html'
" unix/linux oriented
elseif ext==?'fig'
let mt = 'image/x-fig'
endif
return mt
endfu
"id=Utl_processFragmentText-----------------------------------------------------
" Description:
" Position cursor in current buffer according `fragment', modified by
" `fragMode' which can have values 'abs' or 'rel'.
"
" - arg `fragment' can be:
" tn=string - searches string beginning at start position forward.
" The naked fragment (without a `xx=' as prefix defaults
" to tn=).
" tp=string - searches string beginning at start position backward.
" line=number - move cursor number lines from start position. Number
" can be positive or negative. If `fragMode' is 'abs'
" -1 denotes the last line, -2 the before last line etc.
" r=identifier - (IdReference) search for id=identifier\> starting from
" begin of buffer. `fragMode' is ignored.
"
" - arg `fragMode' modifies the start position. Can have the values:
" 'abs' = absolute: Cursor is set to begin or end of document, depending on
" fragment, then position starting from there.
" Start position for tn=, line=nnn, line=+nnn r= is begin of buffer.
" Start position for tp=, line=-nnn is end of buffer.
" 'rel' = relative: Start positioning the cursor from current position.
"
" Details:
" - `fragment' will be URI-Unescaped before processing (e.g. 'tn=A%3aB' ->
" 'tn=A:B')
" - Interpretation of `fragment' depends on the filetype. But currently,
" the only non generic treatment is for HTML references.
" - `Fragment' can be '<undef>' or '' (empty).
" - If `rel' position the cursor to begin or end of line prior to actual
" search: a target string in the same line will not be found.
" (Remark: Intent is to support Same-Document references: avoid that
" the search finds the fragment definition itself. Should not be a
" problem in other cases, e.g. vimhelp scheme)
"
" Known Bugs:
" - For 'abs' search does not find pattern starting at begin of file
"
fu! s:Utl_processFragmentText(fragment, fragMode)
call Utl_trace("- start processing fragment `".a:fragment."' in mode `".a:fragMode."'",1,1)
if a:fragment == '<undef>' || a:fragment == ''
call Utl_trace("- have no or empty fragment")
if a:fragMode=='abs'
call Utl_trace("- since mode is `abs' position cursor to begin of buffer")
call cursor(1,1)
else
call Utl_trace("- since mode is `rel' do nothing")
endif
call Utl_trace("- end processing fragment",1,-1)
return
endif
let ufrag = UtlUri_unescape(a:fragment)
if ufrag != a:fragment
call Utl_trace("- unescaped URL to: `".ufrag."'")
endif
if ufrag =~ '^line=[-+]\=[0-9]*$'
call Utl_trace("- is a `line=' fragment")
let sign = substitute(ufrag, '^line=\([-+]\)\=\([0-9]*\)$', '\1', '')
let num = substitute(ufrag, '^line=\([-+]\)\=\([0-9]*\)$', '\2', '')
if a:fragMode=='abs'
if sign == '-'
call Utl_trace("- negative sign in mode 'abs': position cursor up ".num." lines from end of buffer")
call cursor( line('$') - num + 1, 1 )
else
call Utl_trace("- positive sign in mode 'abs': position cursor to line ".num)
call cursor(num,1)
endif
else
if sign == '-'
call Utl_trace("- negative sign in mode 'rel': position cursor up ".num." lines from current position")
call cursor( line('.') - num , 1 )
else
call Utl_trace("- positive sign in mode 'rel': position cursor down ".num." lines from current position")
call cursor( line('.') + num , 1 )
endif
endif
call Utl_trace("- end processing fragment",1,-1)
return
endif
" (the rest is positioning by search)
" Note: \r is necessary for executing cmd with :normal.
" Note: \M is used in patterns to do search nomagic (e.g. pattern a.c to find a.c
" and not abc).
let fragMode = a:fragMode
let sfwd=1
if ufrag =~ '^r='
call Utl_trace("- is an ID reference. Construct file type dependent search pattern")
" ( \w\@! is normally the same as \> , i.e. match end of word,
" but is not the same in help windows, where 'iskeyword' is
" set to include non word characters. \w\@! is independent of
" settings )
let val = substitute(ufrag, '^r=\(.*\)$', '\1', '')
if &ft == 'html'
call Utl_trace("- file type is 'html' - search for NAME=")
let cmd = '/\c\MNAME=\.\=' . val . '\w\@!' . "\r"
else
call Utl_trace("- file type is not 'html' - search for id=")
let cmd = '/\c\Mid=' . val . '\w\@!' . "\r"
endif
if fragMode=='rel'
call Utl_trace("- search will be with 'wrapscan' (since ID reference anywhere in text)")
let opt_wrapscan='wrapscan'
endif
elseif ufrag =~ '^tp=' " text previous
call Utl_trace("- is a `tp=' (Text Previous) fragment: search backwards")
let cmd = substitute(ufrag, '^tp=\(.*\)$', '?\\c\\M\1\r', '')
let sfwd=0
elseif ufrag =~ '^tn=' " tn= or naked. text next
call Utl_trace("- is a `tn=' (Text Next) fragment: search forward")
let cmd = substitute(ufrag, '^tn=\(.*\)$', '/\\c\\M\1\r', '')
else
call Utl_trace("- is a naked fragment. Is treated like `tn=' (Text Next) fragment: search forward")
let cmd = '/\c\M' . ufrag . "\r" " Note: \c\M vs \\c\\M at <#tp=substitute>
endif
" Initialize Cursor before actual search (CR051)
if fragMode=='abs'
if sfwd==1
call Utl_trace("- forward search in mode 'abs': starting search at begin of buffer")
call cursor(1,1)
else
call Utl_trace("- backward search in mode 'abs': starting search at end of buffer")
call cursor( line('$'), col('$') )
endif
else
if sfwd==1
call Utl_trace("- forward search in mode 'rel': starting search at end of current line")
call cursor( line('.'), col('$') )
else
call Utl_trace("- forward search in mode 'rel': starting search at begin of current line")
call cursor( line('.'), 1)
endif
endif
if ! exists('opt_wrapscan')
let opt_wrapscan = 'nowrapscan'
call Utl_trace("- search will be with 'nowrapscan' (avoid false hit if mode='rel')")
endif
" Do text search (id=fragTextSearch)
" (Should better use search() instead normal / - there is also a w flag)
let saveWrapscan = &wrapscan | exe 'set '.opt_wrapscan | "---[
" (keepjumps because before jump mark is set before link execution (s. #r=_setj ).
" Call cursor() for line= fragments do not change jumps either.)
call Utl_trace("- execute search command: `".cmd."'")
let v:errmsg = ""
silent! exe "keepjumps normal " . cmd
if v:errmsg != ""
let v:errmsg = "fragment address #" . a:fragment . " not found in target"
echohl ErrorMsg | echo v:errmsg | echohl None
endif
let &wrapscan = saveWrapscan "---]
call Utl_trace("- restored previous value for 'wrapscan'")
call Utl_trace("- end processing fragment",1,-1)
endfu
" Utility functions [
"id=Utl_utilExpandConvSpec--------------------------------------------------------
" Expands conversion specifiers like %p in a:str by replacing
" them by there replacement value. Conversion specifier - replacement pairs
" as provided in convSpecDict dictionary.
" Details :
" All occurrences of conversion specifier in a:str will be replaced.
" Specifiers not defined in convSpecDict lead to an error.
" The case of conversion specifier matters, e.g. %p and '%P' are different.
"
" Args:
" str - string to be expanded
" convSpecDict - dictionary containing specifier - replacement entries,
" e.g. 'p' - 'c:/path/to/file'
"
" Returns: List [errormessage, converted string],
" where either or the other is an empty string
"
fu! Utl_utilExpandConvSpec(str, convSpecDict)
let rest = a:str
let out = ''
while 1
let percentPos = stridx(rest, '%')
if percentPos != -1
let left = strpart(rest, 0, percentPos)
let specifier = strpart(rest, percentPos+1, 1)
let rest = strpart(rest, percentPos+2)
else
let out = out . rest
break
endif
if strpart(left, percentPos-1, 1) == '\' " escaped \%
let left = strpart(left, 0, percentPos-1)
let repl = '%' . specifier
else " not escaped
if specifier == ''
return ["Unescaped % character at end of string >".a:str."<", ""]
elseif has_key(a:convSpecDict, specifier)
let repl = a:convSpecDict[specifier]
else
return ["Invalid conversion specifier `%".specifier."' in `".a:str.
\ "'. Valid specifiers are: `". join(map(keys(a:convSpecDict), '"%".v:val')), ""]
endif
endif
let out = out . left . repl
endwhile
return ["",out]
endfu
"-------------------------------------------------------------------------------
" Print tracing messages (with :echo) to see what's going on.
" Only prints if global variable utl_opt_verbose is not 0.
" Currently works only in on/off-manner. Might be extended to distinguish
" trace levels (as Vim's 'verbose' option does, see <url:vimhelp:'verbose'>)
"
" - args
" msg,
" [flush,] boolean, default=1 -> print msg directly
" [incrLevel] number, values= -1 (reduce indent), 0 (unchanged), +1 (augment indent)
" default ist 0 (unchanged)
"
let s:utl_trace_buffer = ''
let s:utl_trace_level = 0
fu! Utl_trace(msg, ...)
if g:utl_opt_verbose == 0
return
endif
"echo " DBG msg=`".a:msg."'"
let flush=1
if exists('a:1')
let flush = a:1
endif
let incrLevel = 0
if exists('a:2')
let incrLevel = a:2
endif
" If negative, do it before printing
if incrLevel < 0
let s:utl_trace_level += incrLevel
" Assertion
if s:utl_trace_level < 0
echohl ErrorMsg
call input("Internal Error: Utl_trace: negative indent. Setting to zero <RETURN>")
echohl None
let s:utl_trace_level = 0
endif
"echo " DBG (changed,before) utl_trace_level=`".s:utl_trace_level."'"
endif
" echohl ErrorMsg
" echo "Error: internal error: s:utl_trace_level < 0: `".s:utl_trace_level."'"
" echohl None
let s:utl_trace_buffer = s:utl_trace_buffer . a:msg
if flush=='1'
" construct indenting corresponding to level
let indentNum = s:utl_trace_level
let indent = ''
while indentNum
"echo " DBG indentNum=`".indentNum."'"
let indent = indent . ' ' " indent depth is two blanks
let indentNum -= 1
endwhile
"echo " DBG indent=`".indent."'"
echo indent . s:utl_trace_buffer
let s:utl_trace_buffer = ''
endif
" If positive, do it after printing
if incrLevel > 0
let s:utl_trace_level += incrLevel
"echo " DBG (changed,after) utl_trace_level=`".s:utl_trace_level."'"
endif
endfu
"-------------------------------------------------------------------------------
" Descr: Creates a file named a:outFile as a copy of file a:srcFile, where
" only the lines between the first and the second occurrence of a:mark are kept.
" Details :
" - a:outFile gets some additional header lines.
" - a:mark is anchored at the beginning of the line (^ search)
" - a:mark is taken literally (search with \M - nomagic for it)
"
" Collaboration:
" - Shows result to user by prompting hit-any-key
" - Except for use of utl_trace function pure utility function.
"
" Ret: -
"
"
fu! Utl_utilCopyExtract(srcFile, outFile, mark)
call Utl_trace("- start Utl_utilCopyExtract(".a:srcFile.",".a:outFile.",".a:mark.")",1,1)
let go_back = 'b ' . bufnr("%")
enew!
exe 'read '.a:srcFile
setl noswapfile modifiable
norm gg
let buf = bufnr("%")
" Delete from first line to the first line that starts with a:mark
let delCmd='1,/\M^'.a:mark.'/d'
call Utl_trace("- command to delete from top to begin mark= `".delCmd."'")
exe delCmd
" Delete from the now first line that starts with a:mark to the end of the text
let delCmd='/\M^'.a:mark.'/,$d'
call Utl_trace("- command to delete from end mark to bottom= `".delCmd."'")
exe delCmd
0insert
' *****
' CREATED BY VIM PLUGIN UTL.VIM BY FUNCTION Utl_utilCopyExtract()
' *****
.
exe 'w! '.a:outFile
exe go_back
exe 'bwipeout ' . buf
echohl MoreMsg
call input("Success: Created file ".a:outFile." <RETURN>")
echohl None
call Utl_trace("- end Utl_utilCopyExtract()",1,-1)
endfu
"-------------------------------------------------------------------------------
" Substitute all slashes with forward slashes in copy of a:str and return it.
fu! Utl_utilFwd2BackSlashes(str)
return substitute( a:str , '/', '\', 'g')
endfu
"-------------------------------------------------------------------------------
" Substitute all backslashes with slashes in copy of a:str and return it.
fu! Utl_utilBack2FwdSlashes(str)
return substitute( a:str , '\', '/', 'g')
endfu
" ]
" BEGIN OF DEFINITION OF STANDARD UTL `DRIVERS' " id=utl_drivers [
"-------------------------------------------------------------------------------
" Retrieve a resource from the web using the wget network retriever.
" Function designed as g:utl_cfg_hdl_scm_http interface function, e.g. intended to
" be used via :let g:utl_cfg_hdl_scm_http="call Utl_if_hdl_scm_http__wget('%u')".
" See also #r=utl_cfg_hdl_scm_http__wget
"
" Arg: url - URL to be downloaded
" Ret: global Vim var g:utl__hdl_scm_ret_list set, containing one element:
" the name of a temporary file where wget downloaded into.
"
" Setup: See <url:config:#r=utl_if_hdl_scm_http_wget_setup>
"
fu! Utl_if_hdl_scm_http__wget(url)
call Utl_trace("- start Utl_if_hdl_scm_http__wget(".a:url.")",1,1)
" Possibly transfer suffix from URL to tempname for correct subsequent
" media type handling If no suffix then assume 'html' (ok for
" http://www.vim.org -> index.html). But is not generally ok
" (example: http://www.vim.org/download.php).
" TODO:
" Should determine media type from HTTP Header, e.g.
" wget --save-headers -> Content-Type: text/html)
let suffix = fnamemodify( UtlUri_path(a:url), ":e")
if suffix == ''
let suffix = 'html'
endif
let tmpFile = Utl_utilBack2FwdSlashes( tempname() ) .'.'.suffix
call Utl_trace("- tmpFile name with best guess suffix: ".tmpFile)
if ! executable('wget')
call Utl_trace("- Vim variable g:utl_cfg_hdl_scm_mail does not exist")
echohl WarningMsg
let v:errmsg="No executable `wget' found."
call input( v:errmsg . " Entering Setup now. <RETURN>")
echohl None
Utl openLink config:#r=utl_if_hdl_scm_http_wget_setup split
call Utl_trace("- end execution of Utl_AddressScheme_mail",1,-1)
return
endif
let cmd = '!wget '.a:url.' -O '.tmpFile
call Utl_trace("- executing cmd: `".cmd."'")
exe cmd
call Utl_trace("- setting global list g:utl__hdl_scm_ret_list to `[".tmpFile."]'")
let g:utl__hdl_scm_ret_list = [tmpFile]
call Utl_trace("- end Utl_if_hdl_scm_http__wget()",1,-1)
endfu
"-------------------------------------------------------------------------------
" Display an email in Outlook
" Function designed as g:utl_cfg_hdl_scm_mail interface function, e.g. intended to
" be used via :let g:utl_cfg_hdl_scm_mail="call Utl_if_hdl_scm_mail__outlook('%a',
" '%p','%d','%f','%s')". See also #r=utl_cfg_hdl_scm_mail__outlook
"
" Args: ...
" Ret: -
"
" Setup: See <url:config:#r=utl_if_hdl_scm_mail__outlook_setup>
fu! Utl_if_hdl_scm_mail__outlook(authority, path, date, from, subject)
call Utl_trace("- start Utl_if_hdl_scm_mail__outlook(".a:authority.",".a:path.",".a:date.",".a:from.",".a:subject.")",1,1)
if ! exists('g:utl__file_if_hdl_scm__outlook')
let g:utl__file_if_hdl_scm__outlook = fnamemodify(g:utl__file, ":h") . '/../utl_if_hdl_scm__outlook.vbs'
call Utl_trace("- configure interface handler variable for Outlook g:utl__file_if_hdl_scm__outlook=")
call Utl_trace(" ".g:utl__file_if_hdl_scm__outlook)
endif
if ! filereadable(g:utl__file_if_hdl_scm__outlook)
echohl WarningMsg
let v:errmsg="No Outlook interface found."
call input( v:errmsg . " Entering Setup now. <RETURN>")
echohl None
Utl openLink config:#r=Utl_if_hdl_scm_mail__outlook_setup split
call Utl_trace("- end Utl_if_hdl_scm_mail__outlook()",1,-1)
return
endif
let cmd='!start wscript "'.g:utl__file_if_hdl_scm__outlook .'" "'. a:authority.'" "'.a:path.'" "'.a:date.'" "'.a:from.'" "'.a:subject.'"'
call Utl_trace("- executing cmd: `".cmd."'")
exe cmd
call Utl_trace("- end Utl_if_hdl_scm_mail__outlook()",1,-1)
endfu
"-------------------------------------------------------------------------------
" Display a file in Acrobat Reader. #page=123 Fragments are supported, i.e.
" display the file at this given page.
" Function designed as g:utl_cfg_hdl_mt_application_pdf interface function,
" e.g. intended to be used via :let g:utl_cfg_hdl_mt_application_pdf="call
" Utl_if_hdl_mt_application_pdf_acrobat('%P', '%f')".
" See also #r=utl_cfg_hdl_mt_application_pdf_acrobat.
"
" Arg: path - file to be displayed in Acrobat (full path)
" fragment - fragment (without #) or empty string if no fragment
"
" Ret: -
"
" Setup: See <config:#r=Utl_if_hdl_mt_application_pdf_acrobat_setup>
"
fu! Utl_if_hdl_mt_application_pdf_acrobat(path,fragment)
call Utl_trace("- start Utl_if_hdl_mt_application_pdf_acrobat(".a:path.",".a:fragment.")",1,1)
let switches = ''
if a:fragment != ''
let ufrag = UtlUri_unescape(a:fragment)
if ufrag =~ '^page='
let fval = substitute(ufrag, '^page=', '', '')
let switches = '/a page='.fval
else
echohl ErrorMsg
echo "Unsupported fragment `#".ufrag."' Valid only `#page='"
echohl None
return
endif
endif
if ! exists('g:utl_cfg_hdl_mt_application_pdf_acrobat_exe_path') " Entering setup
call Utl_trace("- Vim variable `g:utl_cfg_hdl_mt_application_pdf_acrobat_exe_path.' does not exist")
echohl WarningMsg
call input('variable g:utl_cfg_hdl_mt_application_pdf_acrobat_exe_path not defined. Entering Setup now. <RETURN>')
echohl None
Utl openLink config:#r=Utl_if_hdl_mt_application_pdf_acrobat_setup split
call Utl_trace("- end Utl_if_hdl_mt_application_pdf_acrobat() (not successful)",1,-1)
return
endif
" id=ar_switches
let cmd = ':silent !start '.g:utl_cfg_hdl_mt_application_pdf_acrobat_exe_path.' /a page='.ufrag.' "'.a:path.'"'
call Utl_trace("- executing cmd: `".cmd."'")
exe cmd
call Utl_trace("- end Utl_if_hdl_mt_application_pdf_acrobat()",1,-1)
endfu
"-------------------------------------------------------------------------------
" Display a file in MS-Word. #tn=text Fragments are supported, i.e.
" display the file at position of first occurrence of text.
" Function designed as g:utl_cfg_hdl_mt_application_msword interface function,
" e.g. intended to be used via :let g:utl_cfg_hdl_mt_application_msword="call
" Utl_if_hdl_mt_application_msword__word('%P', '%f')".
" See also #r=utl_cfg_hdl_mt_application_msword__word.
"
" Arg: path - file to be displayed in Acrobat (full path)
" fragment - fragment (without #) or empty string if no fragment
"
" Ret: -
"
" Setup: See <config:#r=Utl_if_hdl_mt_application_msword__word_setup>
"
fu! Utl_if_hdl_mt_application_msword__word(path,fragment)
call Utl_trace("- start Utl_if_hdl_mt_application_msword__word(".a:path.",".a:fragment.")",1,1)
if ! exists('g:utl__file_if_hdl_mt_application_msword__word')
let g:utl__file_if_hdl_mt_application_msword__word = fnamemodify(g:utl__file, ":h") . '/../utl_if_hdl_mt_application_msword__word.vbs'
call Utl_trace("- configure interface handler variable for MS-Word g:utl__file_if_hdl_mt_application_msword__word=")
call Utl_trace(" ".g:utl__file_if_hdl_mt_application_msword__word)
endif
if ! filereadable(g:utl__file_if_hdl_mt_application_msword__word)
echohl WarningMsg
let v:errmsg="No Word interface found."
call input( v:errmsg . " Entering Setup now. <RETURN>")
echohl None
Utl openLink config:#r=Utl_if_hdl_mt_application_msword__word_setup split
call Utl_trace("- end Utl_if_hdl_mt_application_msword__word() (not successful)",1,-1)
return
endif
if ! exists('g:utl_cfg_hdl_mt_application_msword__word_exe_path') " Entering setup
call Utl_trace("- Vim variable `g:utl_cfg_hdl_mt_application_pdf_acrobat_exe_path.' does not exist")
echohl WarningMsg
call input('variable g:utl_cfg_hdl_mt_application_msword__word_exe_path not defined. Entering Setup now. <RETURN>')
echohl None
Utl openLink config:#r=Utl_if_hdl_mt_application_msword__word_setup split
call Utl_trace("- end Utl_if_hdl_mt_application_msword__word() (not successful)",1,-1)
return
endif
let cmd = 'silent !start '.g:utl_cfg_hdl_mt_application_msword__word_exe_path.' "'.a:path.'"'
call Utl_trace("- cmd to open document: `".cmd."'")
exe cmd
if a:fragment == ''
call Utl_trace("- end Utl_if_hdl_mt_application_msword__word() (successful, no fragment)",1,-1)
return
endif
" (CR044:frag)
let ufrag = UtlUri_unescape(a:fragment)
if ufrag =~ '^tn=' " text next / text previous
let fval = substitute(ufrag, '^tn=', '', '')
elseif ufrag =~ '[a-z]\+='
echohl ErrorMsg
echo 'Unsupported fragment key `'.substitute(ufrag, '\c^\([a-z]\+\).*', '\1=', '')."'. Valid only: `tn='"
echohl None
call Utl_trace("- end Utl_if_hdl_mt_application_msword__word() (not successful)",1,-1)
return
else
let fval=ufrag " naked fragment same as tn=
endif
let cmd='silent !start wscript "'.g:utl__file_if_hdl_mt_application_msword__word .'" "'. a:path.'" "'.fval.'"'
call Utl_trace("- cmd to address fragment: `".cmd."'")
exe cmd
call Utl_trace("- end Utl_if_hdl_mt_application_msword__word()",1,-1)
endfu
let &cpo = s:save_cpo
finish
=== FILE_OUTLOOK_VBS {{{
' file: utl_if_hdl_scm__outlook.vbs
' synopsis: utl_if_hdl_scm__outlook.vbs "" "Inbox" "08.02.2008 13:31" "" ""
' collaboration: - Used by utl.vim when accessing "mail:" URLs using MS-Outlook.
' - Outlook must be running
' hist:
' 2008-02-29/Stb: Version for Utl.vim v3.0a
Option Explicit
Dim ol, olns, folder, entryId, item, myNewFolder
Dim a_authority, a_path, a_from, a_subject, a_date
a_authority = WScript.Arguments(0)
a_path = WScript.Arguments(1)
a_date = WScript.Arguments(2)
a_from = WScript.Arguments(3)
a_subject = WScript.Arguments(4)
if a_from <> "" Then
MsgBox "utl_if_hdl_scm__outlook.vbs: Sorry: from= query not supported. Will be ignored"
end if
if a_from <> "" Then
MsgBox "utl_if_hdl_scm__outlook.vbs: Sorry: subject= query not supported. Will be ignored"
end if
Set ol = GetObject(, "Outlook.Application")
Set olns = ol.GetNameSpace("MAPI")
'-----
' Get root folder
if a_authority = "" Then
' No a_authority defaults to folder which contains the default folders
Set folder = olns.GetDefaultFolder(6)
Set folder = folder.Parent
else
Set folder = olns.Folders.item( a_authority )
end if
'-----
' Trailing slash possible even with no path defined.
' So remove it independently of path treatment
if a_path <> "" Then
' Remove leading "/"
a_path = Right( a_path, Len(a_path)-1 )
end if
'-----
' If a_path given search a_path recursively to get corresponding
' folder object (currently no hierarchies, only one subfolder)
if a_path <> "" Then
Set folder = folder.Folders.item( a_path )
end if
Dim sFilter
'-----
' Four minute time range turned out to work fairly well finally...
Dim dateMin, dateMax
dateMin = CStr( DateAdd("n", -2, a_date) )
dateMax = CStr( DateAdd("n", 2, a_date) )
' cut seconds added by DateAdd
dateMin = Left(dateMin, Len(dateMin) -3 )
dateMax = Left(dateMax, Len(dateMax) -3 )
'id=adapt_column_name
' Unless you have a german Outlook adapt the following line to match you language.
' The Word "Erhalten" probably something like "Received" in english.
' Have a look in you Outlook; its the name of the column which shows and sorts
' by date.
'
'
' [id=received] Change to actual column name in your Outlook
' +---------------------------------+
' v v
sFilter = "[Erhalten] > '" + dateMin + "' AND [Erhalten] < '" + dateMax + "'"
Set item = folder.Items.find(sFilter)
item.Display
=== FILE_OUTLOOK_VBS }}}
=== FILE_WORD_VBS {{{
' usage: utl_if_hdl_mt_application_msword__word.vbs <.doc file> <string_to_search>
' description: Position cursor in Word document <.doc file> at string
' <string_to_search>
' Collaboration: Word being started or running. Document subject to fragment
' addressing active or being opened and activated.
' hist:
' 2008-03-20/Stb: Version for Utl.vim v3.0a
' TODO: "Option Explicit" ( Can't get it running with... %-/ )
const wdGoToPage = 1
const wdGoToAbsolute = 1
const wdFindContinue = 1
docPath = WScript.Arguments(0)
fragment = WScript.Arguments(1)
' Wait for WORD in case it just starts up
countTries = 0
maxTries = 50
Do While countTries < maxTries
countTries = countTries+1
On Error Resume Next
Set o = GetObject(, "Word.Application")
If Err Then
WScript.Sleep 200
Err.Clear
Else
Exit Do
End If
Loop
' TODO: Exit if still not loaded
' Wait until document loaded
countTries = 0
maxTries = 20
docFound = FALSE
Do While countTries < maxTries
countTries = countTries+1
' schauen ob ActiveDocument.Name (schon) gleich
' dem docPath ist.
pos = InStr(1, docPath, o.ActiveDocument.Name, 1)
If pos <> 0 then
docFound = TRUE
Exit Do
End If
WScript.Sleep 200
Loop
If docFound=FALSE then
WScript.Echo("Document not found")
End If
' TODO: Exit If docFound=FALSE
' assertion: document active
' process fragment
' TODO: support also page= fragment:
' 'o.Selection.GoTo wdGotoPage, wdGoToAbsolute, 20
o.Selection.Find.ClearFormatting
With o.Selection.Find
.Text = fragment
.Replacement.Text = ""
.Forward = True
.Wrap = wdFindContinue
.Format = False
.MatchCase = False
.MatchWholeWord = False
.MatchWildcards = False
.MatchSoundsLike = False
.MatchAllWordForms = False
End With
o.Selection.Find.Execute
=== FILE_WORD_VBS }}}
" END OF DEFINITION OF STANDARD UTL `DRIVERS' ]
" vim: set foldmethod=marker:
" -----id=foot1
" Thanks for trying out Utl.vim :-)
View git blame Copy permalink