" Vimball Archiver by Charles E. Campbell, Ph.D.
UseVimball
finish
plugin/RunView.vim	[[[1
258
" RunView:
"   Author: Charles E. Campbell
"   Date:   Mar 03, 2022
"   Version: 4f	ASTRO-ONLY
" Copyright:    Copyright (C) 2005-2013 Charles E. Campbell {{{1
"               Permission is hereby granted to use and distribute this code,
"               with or without modifications, provided that this copyright
"               notice is copied with it. Like most software that's free,
"               RunView.vim is provided *as is* and comes with no warranty
"               of any kind, either expressed or implied. By using this
"               plugin, you agree that in no event will the copyright
"               holder be liable for any damages resulting from the use
"               of this software.
" GetLatestVimScripts: 2511 1 :AutoInstall: RunView.vim

" ---------------------------------------------------------------------
"  Load Once: {{{1
if &cp || exists("g:loaded_RunView")
 finish
endif
let g:loaded_RunView= "v4e"
"DechoTabOn

" ---------------------------------------------------------------------
"  Defaults: {{{1
if  exists("g:runview_filtcmd") && !exists("b:runview_filtcmd")
 let b:runview_filtcmd= g:runview_filtcmd
elseif !exists("b:runview_filtcmd")
 let b:runview_filtcmd= "ksh"
endif
if !exists("g:runview_swapwin")
 let g:runview_swapwin= 1
endif

" ---------------------------------------------------------------------
"  Public Interface: {{{1
com!      -bang -range=% -nargs=* RunView let s:winposn= SaveWinPosn(0)|sil <line1>,<line2>call s:RunView(<bang>0,<f-args>)
sil! com  -bang -range=% -nargs=* RV      let s:winposn= SaveWinPosn(0)|sil <line1>,<line2>call s:RunView(<bang>0,<f-args>)
sil! com  -bang -range=% -nargs=* DRV     let s:winposn= SaveWinPosn(0)|sil <line1>,<line2>call s:RunView(2,<f-args>)

" \rh map: RunView filter-command
if !hasmapto('<Plug>RunViewH')
 vmap <unique> <Leader>rh <Plug>RunViewH
endif
vmap <silent> <script> <Plug>RunViewH	:let s:winposn= SaveWinPosn(0)<bar>call <SID>RunView(0)<cr>

" \rv map: RunView! filter-command
if !hasmapto('<Plug>RunViewV')
 vmap <unique> <Leader>rv <Plug>RunViewV
endif
vmap <silent> <script> <Plug>RunViewV	:let s:winposn= SaveWinPosn(0)<bar>call <SID>RunView(1)<cr>

" =====================================================================
"  Functions: {{{1

" ---------------------------------------------------------------------
" RunView: {{{2
"   v  : controls whether 0=horizontal or 1=vertical splitting is used (default: vertical splitting)
"   ...: if present, use provided argument as the filter command (unless it begins with a "-")
"        by default, uses b:runview_filtcmd
"        If present and begins with a "-", then the argument is provided as an option to b:runview_filtcmd
fun! s:RunView(v,...) range
"  call Dfunc("RunView(v=".a:v.") [".a:firstline.",".a:lastline."] a:0=".a:0." ft<".&ft.">")

  " if in a runview window, try the left window first
  if &ft == "runview"
   wincmd h
  endif
"  if a:0 >= 1|call Decho("a:1<".a:1.">")|endif
"  if a:0 >= 2|call Decho("a:2<".a:2.">")|endif
  let dodbg= 0
  if a:0 >= 1 && a:1 == "-@@2"
   let dodbg = 1
"   call Decho("set dodbg=1")
  endif

  " set splitright to zero while in this function
  let keep_splitright= &splitright
  let keep_splitbelow= &splitbelow
  setl nosplitright nosplitbelow
"  call Decho("set nosplitright nosplitbelow")

  " If there's an argument of "-", then apply subsequent arguments to filter command:
  "    :RV - arg1 arg2 arg3 ...
  "    ie. the filter used is: b:runview_filtcmd arg1 arg2 arg3
  " Otherwise, if an argument provided, use it as filter-command.  Use it as the current filter subsequently.
  " Otherwise, use the current filter.
  "   The current filter defaults to  b:runview_filtcmd  if it exists
  "                                   g:runview_filtcmd  if it exists
  "                                   "ksh"              otherwise
  " The current filter is stored in:  b:runview_filtcmd
  if a:0 > 0 && a:1 != "" && !dodbg
"   call Decho("case [a:0=".a:0."]>0 && [a:1=".a:1.'] != ""')

   if a:1 =~ '^-$'
"	call Decho('a:1 matches ^-$, so set filtcmd=[b:runview_filtcmd<'.b:runview_filtcmd.'>')
    let filtcmd = b:runview_filtcmd
    let i= 2
	while i <= a:0
	 let filtcmd = filtcmd." ".a:{i}
	 let i       = i + 1
	endwhile
   else
    " use argument as filter command
    let b:runview_filtcmd = a:1
	let filtcmd           = a:1
"	call Decho("set b:runview_filtcmd=[a:1=".a:1."]")
   endif

  elseif exists("b:runview_filtcmd")
"   call Decho("no input args: b:runview_filtcmd<".b:runview_filtcmd.">")
   " use buffer-local filter command
   let filtcmd = b:runview_filtcmd

  else " no input arguments, no b:runview_filtcmd: no idea what to do
"   call Decho("no input args, no b:runview_filtcmd")
   echohl WarningMsg | echomsg "(RunView) no filter command present!" | echohl None
"   call Dret("RunView")
   return
  endif

  let filtcmdfile= substitute(filtcmd,' .*$','','')
"  call Decho("filtcmd    <".filtcmd.">")
"  call Decho("filtcmdfile<".filtcmdfile.">")
  " sanity check
  let barecmd= substitute(filtcmd,'\s.*$','','')
  if !executable(barecmd)
   echohl WarningMsg
   echomsg "***warning*** filtcmd<".barecmd."> not executable!"
   echohl None
"   call Decho("failed sanity check: filtcmd<".barecmd."> is NOT executable")
  else
"   call Decho("passed sanity check: filtcmd<".barecmd."> is executable")
  endif

  " get a copy of the selected lines
  let keepa   = @a
  let marka   = getpos("'a")
  let curfile = expand("%")
  let curname = bufname("%")
  exe "sil ".a:firstline.",".a:lastline."y a"
  if filtcmd =~ '-@'
   " insert curfile before -@
   let winout = substitute(filtcmd,'^\(.*\)\(-@ .*\)$','\1','')." ".curfile." ".substitute(filtcmd,'^\(.*\)\(-@ .*\)$','\2','')
  else
   let winout = filtcmd.' '.curfile
  endif
"  call Decho("curfile<".curfile.">")
"  call Decho("winout<".winout.">")

  if bufexists(filtcmdfile) && bufwinnr(filtcmdfile) > 0
   " output window already exists by given name.
   " Place delimiter and append output to it
"   call Decho("output window<".filtcmdfile."> already exists, appending to it")
   let curwin  = winnr()
   let bufout  = bufwinnr(filtcmdfile)
   exe bufout."wincmd w"
"   call Decho("filecmdfile<".filtcmdfile."> curwin#".curwin." bufout#".bufout)
   setl ma
   let lastline= line("$")
"   call Decho("lastline=".lastline)
   let delimstring = "===".strftime("%m/%d/%y %H:%M:%S")."==="
   call setline(lastline+1,delimstring)
   $

   " run the filter command here
   if filtcmd =~ '\s%\(\s\|$\)'
	let winout= substitute(filtcmd,'\(\s\)%\(\s\|$\)','\1'.curname.'\2','')
"	call Decho("method1: exe sil r !".winout)
	exe "sil r !".winout
   else
    sil put a
    let lastlinep2= lastline + 2
"	call Decho("method2: exe sil ".lastlinep2.",$!".filtcmd)
    exe "sil ".lastlinep2.",$!".filtcmd
   endif

   setl noma nomod bh=wipe
   $
   call search('^===','bcW')
   exe "norm! z\<cr>"
   redraw
   exe curwin."wincmd w"

  else
   " (vertically) split and run register a's lines through filtcmd
"   call Decho("split and run filtcmd<".filtcmd.">")
"   call Decho("curname<".curname.">")
   if !a:v || a:v == 2
    vert new
"	call Decho("vert new")
   elseif a:v == 1
    new
"	call Decho("new")
   endif
   setlocal ma buftype=nofile bh=wipe noswapfile
   " actually run the command as a filter
   if filtcmd =~ '\s%\(\s\|$\)'
	let winout= substitute(filtcmd,'\(\s\)%\(\s\|$\)','\1'.curname.'\2','')
	sil! %d _
"	call Decho("method3: exe sil r !".winout)
	exe "sil r !".winout
   else
    sil put a
	if a:v == 2 || dodbg
	 " run with trailing -@@2 for debugging
"	 call Decho('method4a: sil %!'.filtcmd.'" -@@2"')
	 sleep 5
     exe "sil %!".filtcmd.' -@@2'
	else
"	 call Decho('method4b: exe sil %!'.filtcmd)
     exe "sil %!".filtcmd
	endif
   endif
   exe "file ".fnameescape(filtcmdfile)
   let title       = 'RunView '.filtcmd.' Output Window'
   let delimstring = "===".strftime("%m/%d/%y %H:%M:%S")."==="
   1
   sil put!=''
   put =''
   call setline(1,title)
   call setline(2,delimstring)
   sil 3
   setl ft=runview
   setl noma nomod
   $
   call search('^===','bcW')
   exe "norm! z\<cr>"
   redraw
   if g:runview_swapwin == 1
"	call Decho("exchange windows  (g:runview_swapwin=".g:runview_swapwin.")")
    wincmd x
   else
"	call Decho("move window to above/lef  (g:runview_swapwin=".g:runview_swapwin.")")t
    wincmd w
   endif
  endif

  " restore register a, splitright, and splitbelow
"  call Decho("restore register 2, splitright, splitbelow")
  let @a          = keepa
  let &splitright = keep_splitright
  let &splitbelow = keep_splitbelow
  call setpos("'a",marka)

  " restore position in script buffer
"  call Decho("restoring winposn")
  call RestoreWinPosn(s:winposn)

  " place cursor in results window
  wincmd w

"  call Dret("RunView")
endfun

" ---------------------------------------------------------------------
"  Modelines: {{{1
"  vim: fdm=marker
syntax/runview.vim	[[[1
25
" Runview:
"  Language: runview
"  Maintainer: Charles E. Campbell
"  Last change: Sep 17, 2009

" Remove any old syntax stuff hanging around
syn clear

syn match runviewNmbr	'\<[-+]\=[iIj]\=\%(\.\d\+\)\=\%([eE][-+]\d\+\)\='
syn match runviewNmbr	'\<[-+]\=[iIj]\=\d\+\%(\.\d*\)\=\%([eE][-+]\d\+\)\='
syn match runviewOp		'[=]'
syn match runviewOK		'\<[ij]\a'
syn match runviewSep	"----*"

syn match runviewTitle	"\%1lRunView.*$"
syn match runviewSep	"^===\d.*$"

if !exists("did_runview_syntax")
 let did_runview_syntax= 1
 hi link runviewTitle	Title
 hi link runviewSep		Statement
 hi link runviewNmbr	Number
 hi link runviewOp		Operator
 hi link runviewSep		Delimiter
endif
plugin/cecutil.vim	[[[1
601
" cecutil.vim : save/restore window position
"               save/restore mark position
"               save/restore selected user maps
"  Author:	Charles E. Campbell
"  Version:	18k	ASTRO-ONLY
"  Date:	Nov 22, 2017
"
"  Saving Restoring Destroying Marks: {{{1
"       call SaveMark(markname)       let savemark= SaveMark(markname)
"       call RestoreMark(markname)    call RestoreMark(savemark)
"       call DestroyMark(markname)
"       commands: SM RM DM
"
"  Saving Restoring Destroying Window Position: {{{1
"       call SaveWinPosn()        let winposn= SaveWinPosn()
"       call RestoreWinPosn()     call RestoreWinPosn(winposn)
"		\swp : save current window/buffer's position
"		\rwp : restore current window/buffer's previous position
"       commands: SWP RWP
"
"  Saving And Restoring User Maps: {{{1
"       call SaveUserMaps(mapmode,maplead,mapchx,suffix)
"       call RestoreUserMaps(suffix)
"
" GetLatestVimScripts: 1066 1 :AutoInstall: cecutil.vim
"
" You believe that God is one. You do well. The demons also {{{1
" believe, and shudder. But do you want to know, vain man, that
" faith apart from works is dead?  (James 2:19,20 WEB)
"redraw!|call inputsave()|call input("Press <cr> to continue")|call inputrestore()

" ---------------------------------------------------------------------
" Load Once: {{{1
if &cp || exists("g:loaded_cecutil")
 finish
endif
let g:loaded_cecutil = "v18k"
let s:keepcpo        = &cpo
set cpo&vim
"if exists("g:loaded_Decho")  " Decho
" DechoRemOn
"endif  " Decho

" =======================
"  Public Interface: {{{1
" =======================

" ---------------------------------------------------------------------
"  Map Interface: {{{2
if !hasmapto('<Plug>SaveWinPosn')
 map <unique> <Leader>swp <Plug>SaveWinPosn
endif
if !hasmapto('<Plug>RestoreWinPosn')
 map <unique> <Leader>rwp <Plug>RestoreWinPosn
endif
nmap <silent> <Plug>SaveWinPosn		:call SaveWinPosn()<CR>
nmap <silent> <Plug>RestoreWinPosn	:call RestoreWinPosn()<CR>

" ---------------------------------------------------------------------
" Command Interface: {{{2
com! -bar -nargs=0 SWP	call SaveWinPosn()
com! -bar -nargs=? RWP	call RestoreWinPosn(<args>)
com! -bar -nargs=1 SM	call SaveMark(<q-args>)
com! -bar -nargs=1 RM	call RestoreMark(<q-args>)
com! -bar -nargs=1 DM	call DestroyMark(<q-args>)

com! -bar -nargs=1 WLR	call s:WinLineRestore(<q-args>)

if v:version < 630
 let s:modifier= "sil! "
else
 let s:modifier= "sil! keepj "
endif

" ===============
" Functions: {{{1
" ===============

" ---------------------------------------------------------------------
" SaveWinPosn: {{{2
"    let winposn= SaveWinPosn()  will save window position in winposn variable
"    call SaveWinPosn()          will save window position in b:cecutil_winposn{b:cecutil_iwinposn}
"    let winposn= SaveWinPosn(0) will *only* save window position in winposn variable (no stacking done)
fun! SaveWinPosn(...)
"  echomsg "Decho: SaveWinPosn() a:0=".a:0
  let savedposn= winsaveview()
  if a:0 == 0
   if !exists("b:cecutil_iwinposn")
    let b:cecutil_iwinposn= 1
   else
    let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
   endif
"   echomsg "Decho: saving posn to SWP stack"
   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
  endif
  return savedposn
""  echomsg "Decho: SaveWinPosn() a:0=".a:0
"  if line("$") == 1 && getline(1) == ""
""   echomsg "Decho: SaveWinPosn : empty buffer"
"   return ""
"  endif
"  let so_keep   = &l:so
"  let siso_keep = &siso
"  let ss_keep   = &l:ss
"  setlocal so=0 siso=0 ss=0

"  let swline = line(".")                           " save-window line in file
"  let swcol  = col(".")                            " save-window column in file
"  if swcol >= col("$")
"   let swcol= swcol + virtcol(".") - virtcol("$")  " adjust for virtual edit (cursor past end-of-line)
"  endif
"  let swwline   = winline() - 1                    " save-window window line
"  let swwcol    = virtcol(".") - wincol()          " save-window window column
"  let savedposn = ""
""  echomsg "Decho: sw[".swline.",".swcol."] sww[".swwline.",".swwcol."]"
"  let savedposn = "call GoWinbufnr(".winbufnr(0).")"
"  let savedposn = savedposn."|".s:modifier.swline
"  let savedposn = savedposn."|".s:modifier."norm! 0z\<cr>"
"  if swwline > 0
"   let savedposn= savedposn.":".s:modifier."call s:WinLineRestore(".(swwline+1).")\<cr>"
"  endif
"  if swwcol > 0
"   let savedposn= savedposn.":".s:modifier."norm! 0".swwcol."zl\<cr>"
"  endif
"  let savedposn = savedposn.":".s:modifier."call cursor(".swline.",".swcol.")\<cr>"

"  " save window position in
"  " b:cecutil_winposn_{iwinposn} (stack)
"  " only when SaveWinPosn() is used
"  if a:0 == 0
"   if !exists("b:cecutil_iwinposn")
"    let b:cecutil_iwinposn= 1
"   else
"    let b:cecutil_iwinposn= b:cecutil_iwinposn + 1
"   endif
""   echomsg "Decho: saving posn to SWP stack"
"   let b:cecutil_winposn{b:cecutil_iwinposn}= savedposn
"  endif

"  let &l:so = so_keep
"  let &siso = siso_keep
"  let &l:ss = ss_keep

""  if exists("b:cecutil_iwinposn")                                                                  " Decho
""   echomsg "Decho: b:cecutil_winpos{".b:cecutil_iwinposn."}[".b:cecutil_winposn{b:cecutil_iwinposn}."]"
""  else                                                                                             " Decho
""   echomsg "Decho: b:cecutil_iwinposn doesn't exist"
""  endif                                                                                            " Decho
""  echomsg "Decho: SaveWinPosn [".savedposn."]"
"  return savedposn
endfun

" ---------------------------------------------------------------------
" RestoreWinPosn: {{{2
"      call RestoreWinPosn()
"      call RestoreWinPosn(winposn)
fun! RestoreWinPosn(...)
  if line("$") == 1 && getline(1) == ""
   return ""
  endif
  if a:0 == 0 || type(a:1) != 4
   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
    try
	 call winrestview(b:cecutil_winposn{b:cecutil_iwinposn})
    catch /^Vim\%((\a\+)\)\=:E749/
     " ignore empty buffer error messages
    endtry
    " normally drop top-of-stack by one
    " but while new top-of-stack doesn't exist
    " drop top-of-stack index by one again
    if b:cecutil_iwinposn >= 1
     unlet b:cecutil_winposn{b:cecutil_iwinposn}
     let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
     while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
      let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
     endwhile
     if b:cecutil_iwinposn < 1
      unlet b:cecutil_iwinposn
     endif
    endif
   else
    echohl WarningMsg
    echomsg "***warning*** need to SaveWinPosn first!"
    echohl None
   endif

  else	 " handle input argument
"   echomsg "Decho: using input a:1<".a:1.">"
   " use window position passed to this function
   call winrestview(a:1)
   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
   if exists("b:cecutil_iwinposn")
    let jwinposn= b:cecutil_iwinposn
    while jwinposn >= 1                     " search for a:1 in iwinposn..1
     if exists("b:cecutil_winposn{jwinposn}")    " if it exists
      if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
       unlet b:cecutil_winposn{jwinposn}            " unlet it
       if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
        let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
       endif
      endif
     endif
     let jwinposn= jwinposn - 1
    endwhile
   endif
  endif

""  echomsg "Decho: RestoreWinPosn() a:0=".a:0
""  echomsg "Decho: getline(1)<".getline(1).">"
""  echomsg "Decho: line(.)=".line(".")
"  if line("$") == 1 && getline(1) == ""
""   echomsg "Decho: RestoreWinPosn : empty buffer"
"   return ""
"  endif
"  let so_keep   = &l:so
"  let siso_keep = &l:siso
"  let ss_keep   = &l:ss
"  setlocal so=0 siso=0 ss=0

"  if a:0 == 0 || a:1 == ""
"   " use saved window position in b:cecutil_winposn{b:cecutil_iwinposn} if it exists
"   if exists("b:cecutil_iwinposn") && exists("b:cecutil_winposn{b:cecutil_iwinposn}")
""    echomsg "Decho: using stack b:cecutil_winposn{".b:cecutil_iwinposn."}<".b:cecutil_winposn{b:cecutil_iwinposn}.">"
"    try
"     exe s:modifier.b:cecutil_winposn{b:cecutil_iwinposn}
"    catch /^Vim\%((\a\+)\)\=:E749/
"     " ignore empty buffer error messages
"    endtry
"    " normally drop top-of-stack by one
"    " but while new top-of-stack doesn't exist
"    " drop top-of-stack index by one again
"    if b:cecutil_iwinposn >= 1
"     unlet b:cecutil_winposn{b:cecutil_iwinposn}
"     let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
"     while b:cecutil_iwinposn >= 1 && !exists("b:cecutil_winposn{b:cecutil_iwinposn}")
"      let b:cecutil_iwinposn= b:cecutil_iwinposn - 1
"     endwhile
"     if b:cecutil_iwinposn < 1
"      unlet b:cecutil_iwinposn
"     endif
"    endif
"   else
"    echohl WarningMsg
"    echomsg "***warning*** need to SaveWinPosn first!"
"    echohl None
"   endif

"  else	 " handle input argument
""   echomsg "Decho: using input a:1<".a:1.">"
"   " use window position passed to this function
"   exe a:1
"   " remove a:1 pattern from b:cecutil_winposn{b:cecutil_iwinposn} stack
"   if exists("b:cecutil_iwinposn")
"    let jwinposn= b:cecutil_iwinposn
"    while jwinposn >= 1                     " search for a:1 in iwinposn..1
"     if exists("b:cecutil_winposn{jwinposn}")    " if it exists
"      if a:1 == b:cecutil_winposn{jwinposn}      " and the pattern matches
"       unlet b:cecutil_winposn{jwinposn}            " unlet it
"       if jwinposn == b:cecutil_iwinposn            " if at top-of-stack
"        let b:cecutil_iwinposn= b:cecutil_iwinposn - 1      " drop stacktop by one
"       endif
"      endif
"     endif
"     let jwinposn= jwinposn - 1
"    endwhile
"   endif
"  endif

"  " Seems to be something odd: vertical motions after RWP
"  " cause jump to first column.  The following fixes that.
"  " Note: was using wincol()>1, but with signs, a cursor
"  " at column 1 yields wincol()==3.  Beeping ensued.
"  let vekeep= &ve
"  set ve=all
"  if virtcol('.') > 1
"   exe s:modifier."norm! hl"
"  elseif virtcol(".") < virtcol("$")
"   exe s:modifier."norm! lh"
"  endif
"  let &ve= vekeep

"  let &l:so   = so_keep
"  let &l:siso = siso_keep
"  let &l:ss   = ss_keep

""  echomsg "Decho: RestoreWinPosn"
endfun

" ---------------------------------------------------------------------
" s:WinLineRestore: {{{2
fun! s:WinLineRestore(swwline)
"  echomsg "Decho: s:WinLineRestore(swwline=".a:swwline.")"
  while winline() < a:swwline
   let curwinline= winline()
   exe s:modifier."norm! \<c-y>"
   if curwinline == winline()
	break
   endif
  endwhile
"  echomsg "Decho: s:WinLineRestore"
endfun

" ---------------------------------------------------------------------
" GoWinbufnr: go to window holding given buffer (by number) {{{2
"   Prefers current window; if its buffer number doesn't match,
"   then will try from topleft to bottom right
fun! GoWinbufnr(bufnum)
"  call Dfunc("GoWinbufnr(".a:bufnum.")")
  if winbufnr(0) == a:bufnum
"   call Dret("GoWinbufnr : winbufnr(0)==a:bufnum")
   return
  endif
  winc t
  let first=1
  while winbufnr(0) != a:bufnum && (first || winnr() != 1)
  	winc w
	let first= 0
   endwhile
"  call Dret("GoWinbufnr")
endfun

" ---------------------------------------------------------------------
" SaveMark: sets up a string saving a mark position. {{{2
"           For example, SaveMark("a")
"           Also sets up a global variable, g:savemark_{markname}
fun! SaveMark(markname)
"  call Dfunc("SaveMark(markname<".string(a:markname).">)")
  let markname= a:markname
  if strpart(markname,0,1) !~ '\a'
   let markname= strpart(markname,1,1)
  endif
"  call Decho("markname=".string(markname))

  let lzkeep  = &lz
  set lz

  if 1 <= line("'".markname) && line("'".markname) <= line("$")
   let winposn               = SaveWinPosn(0)
   exe s:modifier."norm! `".markname
   let savemark              = SaveWinPosn(0)
   let g:savemark_{markname} = savemark
   let savemark              = markname.string(savemark)
   call RestoreWinPosn(winposn)
  else
   let g:savemark_{markname} = ""
   let savemark              = ""
  endif

  let &lz= lzkeep

"  call Dret("SaveMark : savemark<".savemark.">")
  return savemark
endfun

" ---------------------------------------------------------------------
" RestoreMark: {{{2
"   call RestoreMark("a")  -or- call RestoreMark(savemark)
fun! RestoreMark(markname)
"  call Dfunc("RestoreMark(markname<".a:markname.">)")

  if strlen(a:markname) <= 0
"   call Dret("RestoreMark : no such mark")
   return
  endif
  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname." strlen(a:markname)=".strlen(a:markname))

  let lzkeep  = &lz
  set lz
  let winposn = SaveWinPosn(0)

  if strlen(a:markname) <= 2
   if exists("g:savemark_{markname}")
	" use global variable g:savemark_{markname}
"	call Decho("use savemark list")
	call RestoreWinPosn(g:savemark_{markname})
	exe "norm! m".markname
   endif
  else
   " markname is a savemark command (string)
"	call Decho("use savemark command")
   let markcmd= strpart(a:markname,1)
  call RestoreWinPosn(winposn)
   exe "norm! m".markname
  endif

  call RestoreWinPosn(winposn)
  let &lz       = lzkeep

"  call Dret("RestoreMark")
endfun

" ---------------------------------------------------------------------
" DestroyMark: {{{2
"   call DestroyMark("a")  -- destroys mark
fun! DestroyMark(markname)
"  call Dfunc("DestroyMark(markname<".a:markname.">)")

  " save options and set to standard values
  let reportkeep= &report
  let lzkeep    = &lz
  set lz report=10000

  let markname= strpart(a:markname,0,1)
  if markname !~ '\a'
   " handles 'a -> a styles
   let markname= strpart(a:markname,1,1)
  endif
"  call Decho("markname=".markname)

  let curmod  = &mod
  let winposn = SaveWinPosn(0)
  1
  let lineone = getline(".")
  exe "k".markname
  d
  put! =lineone
  let &mod    = curmod
  call RestoreWinPosn(winposn)

  " restore options to user settings
  let &report = reportkeep
  let &lz     = lzkeep

"  call Dret("DestroyMark")
endfun

" ---------------------------------------------------------------------
" QArgSplitter: to avoid \ processing by <f-args>, <q-args> is needed. {{{2
" However, <q-args> doesn't split at all, so this one returns a list
" with splits at all whitespace (only!), plus a leading length-of-list.
" The resulting list:  qarglist[0] corresponds to a:0
"                      qarglist[i] corresponds to a:{i}
fun! QArgSplitter(qarg)
"  call Dfunc("QArgSplitter(qarg<".a:qarg.">)")
  let qarglist    = split(a:qarg)
  let qarglistlen = len(qarglist)
  let qarglist    = insert(qarglist,qarglistlen)
"  call Dret("QArgSplitter ".string(qarglist))
  return qarglist
endfun

" ---------------------------------------------------------------------
" ListWinPosn: {{{2
"fun! ListWinPosn()                                                        " Decho 
"  if !exists("b:cecutil_iwinposn") || b:cecutil_iwinposn == 0             " Decho 
"   call Decho("nothing on SWP stack")                                     " Decho
"  else                                                                    " Decho
"   let jwinposn= b:cecutil_iwinposn                                       " Decho 
"   while jwinposn >= 1                                                    " Decho 
"    if exists("b:cecutil_winposn{jwinposn}")                              " Decho 
"     call Decho("winposn{".jwinposn."}<".b:cecutil_winposn{jwinposn}.">") " Decho 
"    else                                                                  " Decho 
"     call Decho("winposn{".jwinposn."} -- doesn't exist")                 " Decho 
"    endif                                                                 " Decho 
"    let jwinposn= jwinposn - 1                                            " Decho 
"   endwhile                                                               " Decho 
"  endif                                                                   " Decho
"endfun                                                                    " Decho 
"com! -nargs=0 LWP	call ListWinPosn()                                    " Decho 

" ---------------------------------------------------------------------
" SaveUserMaps: this function sets up a script-variable (s:restoremap) {{{2
"          which can be used to restore user maps later with
"          call RestoreUserMaps()
"
"          mapmode - see :help maparg for details (n v o i c l "")
"                    ex. "n" = Normal
"                    The letters "b" and "u" are optional prefixes;
"                    The "u" means that the map will also be unmapped
"                    The "b" means that the map has a <buffer> qualifier
"                    ex. "un"  = Normal + unmapping
"                    ex. "bn"  = Normal + <buffer>
"                    ex. "bun" = Normal + <buffer> + unmapping
"                    ex. "ubn" = Normal + <buffer> + unmapping
"          maplead - see mapchx
"          mapchx  - "<something>" handled as a single map item.
"                    ex. "<left>"
"                  - "string" a string of single letters which are actually
"                    multiple two-letter maps (using the maplead:
"                    maplead . each_character_in_string)
"                    ex. maplead="\" and mapchx="abc" saves user mappings for
"                        \a, \b, and \c
"                    Of course, if maplead is "", then for mapchx="abc",
"                    mappings for a, b, and c are saved.
"                  - :something  handled as a single map item, w/o the ":"
"                    ex.  mapchx= ":abc" will save a mapping for "abc"
"          suffix  - a string unique to your plugin
"                    ex.  suffix= "DrawIt"
fun! SaveUserMaps(mapmode,maplead,mapchx,suffix)
"  call Dfunc("SaveUserMaps(mapmode<".a:mapmode."> maplead<".a:maplead."> mapchx<".a:mapchx."> suffix<".a:suffix.">)")

  if !exists("s:restoremap_{a:suffix}")
   " initialize restoremap_suffix to null string
   let s:restoremap_{a:suffix}= ""
  endif

  " set up dounmap: if 1, then save and unmap  (a:mapmode leads with a "u")
  "                 if 0, save only
  let mapmode  = a:mapmode
  let dounmap  = 0
  let dobuffer = ""
  while mapmode =~# '^[bu]'
   if     mapmode =~# '^u'
    let dounmap = 1
    let mapmode = strpart(a:mapmode,1)
   elseif mapmode =~# '^b'
    let dobuffer = "<buffer> "
    let mapmode  = strpart(a:mapmode,1)
   endif
  endwhile
"  call Decho("dounmap=".dounmap."  dobuffer<".dobuffer.">")
 
  " save single map :...something...
  if strpart(a:mapchx,0,1) == ':'
"   call Decho("save single map :...something...")
   let amap= strpart(a:mapchx,1)
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
   endif
   let amap                    = a:maplead.amap
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:sil! ".mapmode."unmap ".dobuffer.amap
   if maparg(amap,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|:".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "sil! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save single map <something>
  elseif strpart(a:mapchx,0,1) == '<'
"   call Decho("save single map <something>")
   let amap       = a:mapchx
   if amap == "|" || amap == "\<c-v>"
    let amap= "\<c-v>".amap
"	call Decho("amap[[".amap."]]")
   endif
   let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
   if maparg(a:mapchx,mapmode) != ""
    let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
   endif
   if dounmap
	exe "sil! ".mapmode."unmap ".dobuffer.amap
   endif
 
  " save multiple maps
  else
"   call Decho("save multiple maps")
   let i= 1
   while i <= strlen(a:mapchx)
    let amap= a:maplead.strpart(a:mapchx,i-1,1)
	if amap == "|" || amap == "\<c-v>"
	 let amap= "\<c-v>".amap
	endif
	let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|sil! ".mapmode."unmap ".dobuffer.amap
    if maparg(amap,mapmode) != ""
     let maprhs                  = substitute(maparg(amap,mapmode),'|','<bar>','ge')
	 let s:restoremap_{a:suffix} = s:restoremap_{a:suffix}."|".mapmode."map ".dobuffer.amap." ".maprhs
    endif
	if dounmap
	 exe "sil! ".mapmode."unmap ".dobuffer.amap
	endif
    let i= i + 1
   endwhile
  endif
"  call Dret("SaveUserMaps : s:restoremap_".a:suffix.": ".s:restoremap_{a:suffix})
endfun

" ---------------------------------------------------------------------
" RestoreUserMaps: {{{2
"   Used to restore user maps saved by SaveUserMaps()
fun! RestoreUserMaps(suffix)
"  call Dfunc("RestoreUserMaps(suffix<".a:suffix.">)")
  if exists("s:restoremap_{a:suffix}")
   let s:restoremap_{a:suffix}= substitute(s:restoremap_{a:suffix},'|\s*$','','e')
   if s:restoremap_{a:suffix} != ""
"   	call Decho("exe ".s:restoremap_{a:suffix})
    exe "sil! ".s:restoremap_{a:suffix}
   endif
   unlet s:restoremap_{a:suffix}
  endif
"  call Dret("RestoreUserMaps")
endfun

" ==============
"  Restore: {{{1
" ==============
let &cpo= s:keepcpo
unlet s:keepcpo

" ================
"  Modelines: {{{1
" ================
" vim: ts=4 fdm=marker
doc/RunView.txt	[[[1
111
*RunView.txt*	RunView					Jan 12, 2018
Copyright:    Copyright (C) 2018 Charles E. Campbell {{{1
              Permission is hereby granted to use and distribute this code,
              with or without modifications, provided that this copyright
              notice is copied with it. Like anything else that's free,
              RunView.vim is provided *as is* and comes with no warranty
              of any kind, either expressed or implied. By using this
              plugin, you agree that in no event will the copyright
              holder be liable for any damages resulting from the use
              of this software.


==============================================================================
1. Contents					*runview* *runview-contents*

	1. Contents..................................: |runview-contents|
	2. Usage.....................................: |runview-usage|
	3. Options...................................: |runview-options|
	4. History...................................: |runview-history|


==============================================================================
2. Usage						*runview-usage*

   COMMAND	*:RunView*  *:RV*
   	:[range]RunView[!] [filtercommand]
   	:[range]RV[!] [filtercommand]

   VISUAL MODE MAPS	*\rh*	*\rv*
	(visual-line-selection) \rh
	(visual-line-selection) \rv

	RunView runs user-selected lines, selected either via a range provided
	to the RunView command or by visual-line selection (|V|), through a
	|filter|.  By default, the filter is ksh; however, the |runview-filtcmd|
	can be set (let g:runview_filtcmd="someotherfilter") in your <.vimrc>
	to override this.  The RunView command lets you specify the filter
	on the command line, too.

	However, if the filtercommand has a "%" in it, then the current file
	name is substituted for the "%" and executed by  :r! filtercommand .

	The output is placed in a separate window; it is horizontally (\rh) or
	vertically (\rv) placed.  Source code is left unchanged and visible.

	Without the !, the RunView command uses vertically stacked windows.
	With the !, the RunView command uses horizontally adjacent windows.

	As an example, consider the file: >
		echo "one"
		echo "two"
		echo "three"
<	Using >
		:%RunView! ksh
<	the source code window is left on top, but the results of filtering
	the three lines is shown below it: >
		echo "one"
		echo "two"
		echo "three"
		-------------
		RunView ksh Output Window
		=== 01/02/05 06:07:08 ===
		one
		two
		three
<	RunView provides a title and a separator.  Subsequent applications
	of RunView will append a new separator line plus the new filter
	output.

	The package contains: >
		plugin/RunView.vim
		syntax/RunView.vim
		doc/RunView.txt
<	

==============================================================================
3. Options				*runview-option* *runview-options*

                      Option Variable     Default Value
                      -----------------   -------------
   *runview-filtcmd*  g:runview_filtcmd   "ksh"
   *runview-swapwin*  g:runview_swapwin   1

	The g:runview_filtcmd specifies the default application that will
	be used to filter lines.

	One may use *b:runview_filtcmd* , too (see |buffer-variable|).
	This variant works well with |ftplugin|s; ie. one can have
	the action that |:RV| takes depend on the filetype.

	If g:runview_swapwin is true, then the source lines and output
	window will be swapped (horizontal: top<>bottom, vertical:left<>right).


==============================================================================
4. History						*runview-history*

	v3 	Nov 25, 2013 *	various bug fixes
		Jul 02, 2015 *	changed %d to use blackhole register (%d _)
		Jan 12, 2018 *	improved decision concerning when to append
				vs when to create a new window for output
	v2	Jan 07, 2009 *	Updated syntax highlighting.
				Changed default to vertical split
		Jul 20, 2010 *	runview buffer now a scratch buffer
				(see |special-buffers|)
		Nov 08, 2011 *	added "%" to let filtercommand take a filename
	v1	Oct 26, 2005 *	Initial release


==============================================================================
vim: ts=8