├── .gitignore
├── MANIFEST
├── META
├── Makefile
├── README
├── README.md
├── addon-info.json
├── autoload
    └── vim_dev_plugin.vim
├── doc
    └── vim-dev-plugin.txt
├── ftplugin
    ├── vim.vim
    └── vim
    │   └── eval.vim
├── plugin
    └── vim_dev_plugin.vim
└── spell
    └── en.utf-8.add


/.gitignore:
--------------------------------------------------------------------------------
1 | doc/tags
2 | .netrwhist
3 | en.utf-8.add.spl
4 | 


--------------------------------------------------------------------------------
/MANIFEST:
--------------------------------------------------------------------------------
1 | ftplugin/vim/omni.vim
2 | Makefile
3 | MANIFEST
4 | MANIFEST.SKIP
5 | META
6 | README.md
7 | test.vim
8 | VIMMETA.yml
9 | 


--------------------------------------------------------------------------------
/META:
--------------------------------------------------------------------------------
 1 | 
 2 | =name           vimomni.vim
 3 | 
 4 | =author         Cornelius
 5 | 
 6 | =email          cornelius.howl@gmail.com
 7 | 
 8 | =type           ftplugin
 9 | 
10 | =version_from   ftplugin/vim/omni.vim
11 | 
12 | =vim_version    >= 7.2
13 | 
14 | =libpath        .
15 | 
16 | =script_id      2922
17 | 
18 | =repository git://....../
19 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | # vim:filetype=make:foldmethod=marker:fdl=0:
  2 | #
  3 | #
  4 | # 	Look at the stars, Look how they shine for you, And everything you do,
  5 | # 	Yeah they were all yellow, 
  6 | #
  7 | # 	I came along, I wrote a song for you, And all the things you do And it was
  8 | # 	called yellow.
  9 | #
 10 | # 	So then I took my turn.  Oh all the things I've done And it was all yellow 
 11 | #
 12 | # 														- Coldplay
 13 | #
 14 | #
 15 | # Makefile: install/uninstall/link vim plugin files.
 16 | # Author: Cornelius <cornelius.howl@gmail.com>
 17 | # Date:   一  3/15 22:49:26 2010
 18 | # Version:  1.0
 19 | #
 20 | # PLEASE DO NOT EDIT THIS FILE. THIS FILE IS AUTO-GENERATED FROM Makefile.tpl
 21 | # LICENSE {{{
 22 | # Copyright (c) 2010 <Cornelius (c9s)>
 23 | #
 24 | # Permission is hereby granted, free of charge, to any person
 25 | # obtaining a copy of this software and associated documentation
 26 | # files (the "Software"), to deal in the Software without
 27 | # restriction, including without limitation the rights to use,
 28 | # copy, modify, merge, publish, distribute, sublicense, and/or sell
 29 | # copies of the Software, and to permit persons to whom the
 30 | # Software is furnished to do so, subject to the following
 31 | # conditions:
 32 | #
 33 | # The above copyright notice and this permission notice shall be
 34 | # included in all copies or substantial portions of the Software.
 35 | #
 36 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 37 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 38 | # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 39 | # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 40 | # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 41 | # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 42 | # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 43 | # OTHER DEALINGS IN THE SOFTWARE.
 44 | # }}}
 45 | # VIM RECORD FORMAT: {{{
 46 | # {
 47 | #           version => 0.2,    # record spec version
 48 | #           generated_by => 'Vimana-' . $Vimana::VERSION,
 49 | #           install_type => 'auto',    # auto , make , rake ... etc
 50 | #           package => $self->package_name,
 51 | #           files => \@e,
 52 | # }
 53 | # }}}
 54 | 
 55 | # INTERNAL VARIABLES {{{
 56 | 
 57 | RECORD_FILE=.record
 58 | PWD=`pwd`
 59 | README_FILES=`ls -1 | grep -i readme`
 60 | WGET_OPT=-c -nv
 61 | CURL_OPT=
 62 | RECORD_SCRIPT=.mkrecord
 63 | TAR=tar czvf
 64 | 
 65 | GIT_SOURCES=
 66 | 
 67 | # INTERNAL FUNCTIONS {{{
 68 | record_file = \
 69 | 		PTYPE=`cat $(1) | perl -nle 'print $$1 if /^"\s*script\s*type:\s*(\S*)$$/i'` ;\
 70 | 		echo $(VIMRUNTIME)/$$PTYPE/$(1) >> $(2)
 71 | 
 72 | # }}}
 73 | 
 74 | # PUBLIC FUNCTIONS {{{
 75 | 
 76 | GIT_SOURCES=
 77 | DEPEND_DIR=/tmp/vim-deps
 78 | 
 79 | # Usage:
 80 | #
 81 | # 		$(call install_git_sources)
 82 | #
 83 | 
 84 | install_git_source = \
 85 | 		PWD=$(PWD) ; \
 86 | 		mkdir -p $(DEPEND_DIR) ; \
 87 | 		cd $(DEPEND_DIR) ; \
 88 | 		for git_uri in $(GIT_SOURCES) ; do \
 89 | 			OUTDIR=$$(echo $$git_uri | perl -pe 's{^.*/}{}') ;\
 90 | 			echo $$OUTDIR ; \
 91 | 			if [[ -e $$OUTDIR ]] ; then \
 92 | 				cd $$OUTDIR ; \
 93 | 				git pull origin master && \
 94 | 				make install && cd .. ; \
 95 | 			else \
 96 | 				git clone $$git_uri $$OUTDIR && \
 97 | 				cd $$OUTDIR && \
 98 | 				make install && cd .. ; \
 99 | 			fi; \
100 | 		done ;
101 | 
102 | 
103 | 
104 | 
105 | # install file by inspecting content
106 | install_file = \
107 | 		PTYPE=`cat $(1) | perl -nle 'print $$1 if /^"\s*script\s*type:\s*(\S*)$$/i'` ;\
108 | 		cp -v $(1) $(VIMRUNTIME)/$$PTYPE/$(1)
109 | 
110 | link_file = \
111 | 		PTYPE=`cat $(1) | perl -nle 'print $$1 if /^"\s*script\s*type:\s*(\S*)$$/i'` ;\
112 | 		cp -v $(1) $(VIMRUNTIME)/$$PTYPE/$(1)
113 | 
114 | unlink_file = \
115 | 		PTYPE=`cat $(1) | perl -nle 'print $$1 if /^"\s*script\s*type:\s*(\S*)$$/i'` ;\
116 | 		rm -fv $(VIMRUNTIME)/$$PTYPE/$(1)
117 | 
118 | # fetch script from an url
119 | fetch_url = \
120 | 		@if [[ -e $(2) ]] ; then 				\
121 | 			exit								\
122 | 		; fi	 							    \
123 | 		; echo " => $(2)"						\
124 | 		; if [[ ! -z `which curl` ]] ; then   \
125 | 			curl $(CURL_OPT) $(1) -o $(2) ;					\
126 | 		; elif [[ ! -z `which wget` ]] ; then 	\
127 | 			wget $(WGET_OPT) $(1) -O $(2)  				    \
128 | 		; fi  									\
129 | 		; echo $(2) >> .bundlefiles
130 | 
131 | 
132 | install_source = \
133 | 		for git_uri in $(GIT_SOURCES) ; do \
134 | 			OUTDIR=$$(echo $$git_uri | perl -pe 's{^.*/}{}') ;\
135 | 			echo $$OUTDIR ; \
136 | 		done
137 | 
138 | # fetch script from github
139 | fetch_github = \
140 | 		@if [[ -e $(5) ]] ; then 				\
141 | 			exit								\
142 | 		; fi	 							    \
143 | 		; echo " => $(5)"						\
144 | 		; if [[ ! -z `which curl` ]] ; then                        	    \
145 | 			curl $(CURL_OPT) http://github.com/$(1)/$(2)/raw/$(3)/$(4) -o $(5)      \
146 | 		; elif [[ ! -z `which wget` ]] ; then                               \
147 | 			wget $(WGET_OPT) http://github.com/$(1)/$(2)/raw/$(3)/$(4) -O $(5)  \
148 | 		; fi									\
149 | 		; echo $(5) >> .bundlefiles
150 | 
151 | # fetch script from local file
152 | fetch_local = @cp -v $(1) $(2) \
153 | 		; @echo $(2) >> .bundlefiles
154 | 
155 | # 1: NAME , 2: URI
156 | dep_from_git = \
157 | 		D=/tmp/$(1)-$$RANDOM ; git clone $(2) $$D ; cd $$D ; make install ; 
158 | 
159 | dep_from_svn = \
160 | 		D=/tmp/$(1)-$$RANDOM ; svn checkout $(2) $$D ; cd $$D ; make install ;
161 | 
162 | # }}}
163 | # }}}
164 | # ======= DEFAULT CONFIG ======= {{{
165 | 
166 | # Default plugin name
167 | NAME=`basename \`pwd\``
168 | VERSION=0.1
169 | 
170 | # Files to add to tarball:
171 | DIRS=`ls -1F | grep / | sed -e 's/\///'`
172 | 
173 | # Runtime path to install:
174 | VIMRUNTIME=~/.vim
175 | 
176 | # Other Files to be added:
177 | FILES=`ls -1 | grep '.vim$$'`
178 | MKFILES=Makefile `ls -1 | grep '.mk$$'`
179 | 
180 | # ======== USER CONFIG ======= {{{
181 | #   please write config in config.mk
182 | #   this will override default config
183 | #
184 | # Custom Name:
185 | #
186 | # 	NAME=[plugin name]
187 | #
188 | # Custom dir list:
189 | #
190 | # 	DIRS=autoload after doc syntax plugin 
191 | #
192 | # Files to add to tarball:
193 | #
194 | # 	FILES=
195 | # 
196 | # Bundle dependent scripts:
197 | #
198 | # 	bundle-deps:
199 | # 	  $(call fetch_github,[account id],[project],[branch],[source path],[target path])
200 | # 	  $(call fetch_url,[file url],[target path])
201 | # 	  $(call fetch_local,[from],[to])
202 | 
203 | SHELL=bash
204 | 
205 | CONFIG_FILE=config.mk
206 | -include ~/.vimauthor.mk
207 | -include $(CONFIG_FILE)
208 | 
209 | # }}}
210 | # }}}
211 | # ======= SECTIONS ======= {{{
212 | -include ext.mk
213 | 
214 | all: install-deps install
215 | 
216 | install-deps:
217 | 	# check required binaries
218 | 	[[ -n $$(which git) ]]
219 | 	[[ -n $$(which bash) ]]
220 | 	[[ -n $$(which vim) ]]
221 | 	[[ -n $$(which wget) || -n $$(which curl) ]]
222 | 	$(call install_git_sources)
223 | 
224 | check-require:
225 | 	@if [[ -n `which wget` || -n `which curl` || -n `which fetch` ]]; then echo "wget|curl|fetch: OK" ; else echo "wget|curl|fetch: NOT OK" ; fi
226 | 	@if [[ -n `which vim` ]] ; then echo "vim: OK" ; else echo "vim: NOT OK" ; fi
227 | 
228 | config:
229 | 	@rm -f $(CONFIG_FILE)
230 | 	@echo "NAME="                                                                                      >> $(CONFIG_FILE)
231 | 	@echo "VERSION="                                                                                           >> $(CONFIG_FILE)
232 | 	@echo "#DIRS="
233 | 	@echo "#FILES="
234 | 	@echo ""                                                                                           >> $(CONFIG_FILE)
235 | 	@echo "bundle-deps:"                                                                               >> $(CONFIG_FILE)
236 | 	@echo "\t\t\$$(call fetch_github,ID,REPOSITORY,BRANCH,PATH,TARGET_PATH)" >> $(CONFIG_FILE)
237 | 	@echo "\t\t\$$(call fetch_url,FILE_URL,TARGET_PATH)"                                           >> $(CONFIG_FILE)
238 | 
239 | 
240 | init-author:
241 | 	@echo "AUTHOR=" > ~/.vimauthor.mk
242 | 
243 | bundle-deps:
244 | 
245 | bundle: bundle-deps
246 | 
247 | dist: bundle mkfilelist
248 | 	@$(TAR) $(NAME)-$(VERSION).tar.gz --exclude '*.svn' --exclude '.git' $(DIRS) $(README_FILES) $(FILES) $(MKFILES)
249 | 	@echo "$(NAME)-$(VERSION).tar.gz is ready."
250 | 
251 | init-runtime:
252 | 	@mkdir -vp $(VIMRUNTIME)
253 | 	@mkdir -vp $(VIMRUNTIME)/record
254 | 	@if [[ -n "$(DIRS)" ]] ; then find $(DIRS) -type d | while read dir ;  do \
255 | 			mkdir -vp $(VIMRUNTIME)/$$dir ; done ; fi
256 | 
257 | release:
258 | 	if [[ -n `which vimup` ]] ; then \
259 | 	fi
260 | 
261 | pure-install:
262 | 	@echo "Using Shell:" $(SHELL) 
263 | 	@echo "Installing"
264 | 	@if [[ -n "$(DIRS)" ]] ; then find $(DIRS) -type f | while read file ; do \
265 | 			cp -v $$file $(VIMRUNTIME)/$$file ; done ; fi
266 | 	@echo "$(FILES)" | while read vimfile ; do \
267 | 		if [[ -n $$vimfile ]] ; then \
268 | 			$(call install_file,$$vimfile) ; fi ; done
269 | 
270 | install: init-runtime bundle pure-install record
271 | 
272 | 
273 | uninstall-files:
274 | 	@echo "Uninstalling"
275 | 	@if [[ -n "$(DIRS)" ]] ; then find $(DIRS) -type f | while read file ; do \
276 | 			rm -fv $(VIMRUNTIME)/$$file ; done ; fi
277 | 	@echo "$(FILES)" | while read vimfile ; do \
278 | 		if [[ -n $$vimfile ]] ; then \
279 | 			$(call unlink_file,$$vimfile) ; fi ; done
280 | 
281 | uninstall: uninstall-files rmrecord
282 | 
283 | link: init-runtime
284 | 	@echo "Linking"
285 | 	@if [[ -n "$(DIRS)" ]]; then find $(DIRS) -type f | while read file ; do \
286 | 			ln -sfv $(PWD)/$$file $(VIMRUNTIME)/$$file ; done ; fi
287 | 	@echo "$(FILES)" | while read vimfile ; do \
288 | 		if [[ -n $$vimfile ]] ; then \
289 | 			$(call link_file,$$vimfile) ; fi ; done
290 | 
291 | mkfilelist:
292 | 	@echo $(NAME) > $(RECORD_FILE)
293 | 	@echo $(VERSION) >> $(RECORD_FILE)
294 | 	@if [[ -n "$(DIRS)" ]] ; then find $(DIRS) -type f | while read file ; do \
295 | 			echo $(VIMRUNTIME)/$$file >> $(RECORD_FILE) ; done ; fi
296 | 	@echo "$(FILES)" | while read vimfile ; do \
297 | 		if [[ -n $$vimfile ]] ; then \
298 | 			$(call record_file,$$vimfile,$(RECORD_FILE)) ; fi ; done
299 | 
300 | vimball-edit:
301 | 	find $(DIRS) -type f > .tmp_list
302 | 	vim .tmp_list
303 | 	vim .tmp_list -c ":MkVimball $(NAME)-$(VERSION) ." -c "q"
304 | 	@rm -vf .tmp_list
305 | 	@echo "$(NAME)-$(VERSION).vba is ready."
306 | 
307 | vimball:
308 | 	find $(DIRS) -type f > .tmp_list
309 | 	vim .tmp_list -c ":MkVimball $(NAME)-$(VERSION) ." -c "q"
310 | 	@rm -vf .tmp_list
311 | 	@echo "$(NAME)-$(VERSION).vba is ready."
312 | 
313 | mkrecordscript:
314 | 		@echo ""  >  $(RECORD_SCRIPT)
315 | 		@echo "fun! s:mkmd5(file)"  >> $(RECORD_SCRIPT)
316 | 		@echo "  if executable('md5')"  >> $(RECORD_SCRIPT)
317 | 		@echo "    return system('cat ' . a:file . ' | md5')"  >> $(RECORD_SCRIPT)
318 | 		@echo "  else"  >> $(RECORD_SCRIPT)
319 | 		@echo "    return \"\""  >> $(RECORD_SCRIPT)
320 | 		@echo "  endif"  >> $(RECORD_SCRIPT)
321 | 		@echo "endf"  >> $(RECORD_SCRIPT)
322 | 		@echo "let files = readfile('.record')"  >> $(RECORD_SCRIPT)
323 | 		@echo "let package_name = remove(files,0)"  >> $(RECORD_SCRIPT)
324 | 		@echo "let script_version      = remove(files,0)"  >> $(RECORD_SCRIPT)
325 | 		@echo "let record = { 'version' : 0.3 , 'generated_by': 'Vim-Makefile' , 'script_version': script_version , 'install_type' : 'makefile' , 'package' : package_name , 'files': [  ] }"  >> $(RECORD_SCRIPT)
326 | 		@echo "for file in files "  >> $(RECORD_SCRIPT)
327 | 		@echo "  let md5 = s:mkmd5(file)"  >> $(RECORD_SCRIPT)
328 | 		@echo "  cal add( record.files , {  'checksum': md5 , 'file': file  } )"  >> $(RECORD_SCRIPT)
329 | 		@echo "endfor"  >> $(RECORD_SCRIPT)
330 | 		@echo "redir => output"  >> $(RECORD_SCRIPT)
331 | 		@echo "silent echon record"  >> $(RECORD_SCRIPT)
332 | 		@echo "redir END"  >> $(RECORD_SCRIPT)
333 | 		@echo "let content = join(split(output,\"\\\\n\"),'')"  >> $(RECORD_SCRIPT)
334 | 		@echo "let record_file = expand('~/.vim/record/' . package_name )"  >> $(RECORD_SCRIPT)
335 | 		@echo "cal writefile( [content] , record_file )"  >> $(RECORD_SCRIPT)
336 | 		@echo "cal delete('.record')"  >> $(RECORD_SCRIPT)
337 | 		@echo "echo \"Done\""  >> $(RECORD_SCRIPT)
338 | 
339 | 
340 | record: mkfilelist mkrecordscript
341 | 	vim --noplugin -V10install.log -c "so $(RECORD_SCRIPT)" -c "q"
342 | 	@echo "Vim script record making log: install.log"
343 | #	@rm -vf $(RECORD_FILE)
344 | 
345 | rmrecord:
346 | 	@echo "Removing Record"
347 | 	@rm -vf $(VIMRUNTIME)/record/$(NAME)
348 | 
349 | clean: clean-bundle-deps
350 | 	@rm -vf $(RECORD_FILE)
351 | 	@rm -vf $(RECORD_SCRIPT)
352 | 	@rm -vf install.log
353 | 	@rm -vf *.tar.gz
354 | 
355 | clean-bundle-deps:
356 | 	@echo "Removing Bundled scripts..."
357 | 	@if [[ -e .bundlefiles ]] ; then \
358 | 		rm -fv `echo \`cat .bundlefiles\``; \
359 | 	fi
360 | 	@rm -fv .bundlefiles
361 | 
362 | update:
363 | 	@echo "Updating Makefile..."
364 | 	@URL=http://github.com/c9s/vim-makefile/raw/master/Makefile ; \
365 | 	if [[ -n `which curl` ]]; then \
366 | 		curl $$URL -o Makefile ; \
367 | 	if [[ -n `which wget` ]]; then \
368 | 		wget -c $$URL ; \
369 | 	elif [[ -n `which fetch` ]]; then \
370 | 		fetch $$URL ; \
371 | 	fi
372 | 
373 | version:
374 | 	@echo version - $(MAKEFILE_VERSION)
375 | 
376 | # }}}
377 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/c9s/vim-dev-plugin/1dced68adc2d0873ea5cdf1780f7351c31a964d3/README


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # Vim plugin for developing vim script.
  3 | 
  4 | 
  5 | ## Eval
  6 |     
  7 | ## Vim Omni Completion
  8 | 
  9 | although vim has its own completion (C-x C-v), but it''s leak of something
 10 | 
 11 | vim omni supports:
 12 | 
 13 |     * builtin command name completion.
 14 |     * builtin function name completion.
 15 |     * runtime command completion.
 16 |     * runtime function name completion.
 17 |     * g:,s:.. scope completion.
 18 |     * option name completion.
 19 |     * autocommand event name completion
 20 |     * feature name completion.
 21 |     * &option
 22 | 
 23 | 
 24 | INSTALL
 25 | =======
 26 | 
 27 | copy `ftplugin/vim/omni.vim` to your `~/.vim/ftplugin/vim/omni.vim`
 28 | Dependencies see addon-info.json
 29 | 
 30 | vim-addon-manager plugin will install all dependencies for you automatically.
 31 | vim-addon- can be found on github.com/MarcWeber tlib is easy to find.
 32 | 
 33 | 
 34 | USE
 35 | ======
 36 | 
 37 | function name:
 38 |     cal <C-x><C-o>
 39 | 
 40 | command name:
 41 |     com! <C-x><C-o>
 42 | 
 43 | var name:
 44 |     let g:<C-x><C-o>
 45 | 
 46 | autocmd event:
 47 |     autocmd <C-x><C-o>
 48 | 
 49 | option name:
 50 |     set <C-x><C-o>
 51 | 
 52 | feature name:
 53 |     if has(<C-x><C-o>
 54 | 
 55 | SCREENSHOT
 56 | ==========
 57 | 
 58 | ![](http://cloud.github.com/downloads/c9s/vimomni.vim/Screen_shot_2010-01-10_at_10.44.58_AM.png)
 59 | ![](http://cloud.github.com/downloads/c9s/vimomni.vim/Screen_shot_2010-01-10_at_10.44.45_AM.png)
 60 | ![](http://cloud.github.com/downloads/c9s/vimomni.vim/Screen_shot_2010-01-10_at_10.44.30_AM.png)
 61 | 
 62 | GOTO function
 63 | ============
 64 | vim-addon-goto-thing-at-cursor remaps gf. By typing gf on a function Vim will
 65 | attempt to jump to its definition. This implementation is not using tags - so
 66 | its always up to date.
 67 | 
 68 | 
 69 | CUSTOMIZATION:
 70 | ===============
 71 | If you dislike camel case matching see vim-addon-ocmpletion how to override the default
 72 | 
 73 | recommended additional plugins
 74 | ==============================
 75 | You may find reload useful which reloads syntax and .vim files.
 76 | You still want to restart Vim to get rid of old definititions etc.
 77 | 
 78 | How to debug VimL ?
 79 | ===================
 80 | use :debug a-command then (c)ontinue (r)eturn (n)ext (s)tep ..
 81 | if you get stackt traces of dict functions you can find the hints about the
 82 | declaration by :function {77} or such.
 83 | 
 84 | output var contents:
 85 | 
 86 | 
 87 |     echoe string(x)  
 88 |     echo x
 89 | 
 90 |     messages will redisplay everything printed by echoe
 91 | 
 92 | 
 93 | or the like
 94 | 
 95 | How to debug all calls of a function F?
 96 | 
 97 | change
 98 | 
 99 | 
100 | 
101 |     fun F()
102 |       " do something
103 |     endf
104 | 
105 | 
106 | 
107 | to 
108 | 
109 | 
110 | 
111 |     fun F(...)
112 |       debug return call(function('F2'), a:000)
113 |     endf
114 | 
115 |     fun F2()
116 |       " do something
117 |     endf
118 | 
119 | 
120 | 
121 | 
122 | then you can use viml debugger:
123 | 
124 |     (c)ontinue, (s)tep, (n)ext
125 | 
126 | and of course you can just type any viml code such as echo to debug vars
127 | 
128 | And of course you can always vim -V20/tmp/log to see all VimL lines being
129 | executed.
130 | 
131 | Also see :h breaka etc
132 | 
133 | If you get error messages suchas 23.34.23
134 | line 3 This mean that the methods 23 34 23 are memebers of dictionaries.
135 | You can view the code by :function{23}
136 | (TODO: Add this to VimLGotoLastError)
137 | 
138 | If you get traces VimLGotoLastError tries to find the location where the error happened
139 | adding the error message. It often works - but not aways
140 | 
141 | How to debug syntax scripts ?
142 | =============================
143 | 
144 | Note: echo lines are ignored by Vim. However you can run an indentation
145 | function manually and read them:
146 | 
147 | fun MyIndent(lnum)
148 |   echo 'debug ..'
149 |   return 1
150 | endfun
151 | 
152 | Then you can debug indentation of current line ..
153 | :echo MyIndent(line('.'))
154 | ^ here you can use debug etc.
155 | 
156 | Howto write a good Vim plugin ?
157 | ===============================
158 | Hard question. There are different styles. I like the following:
159 | 
160 | - Don't start from scratch if you can also join an existing project.
161 |   So do some research or ask on #vim
162 | 
163 | - Try reusing code. vim-addon-manager allows to install dependencies easily.
164 | 
165 | - Consider using a VCS (eg git) so that other devs can join and help you more
166 |   easily (or continue your project if you lost interest).
167 | 
168 | - put code which is not run on every startup into autoload/ files
169 |   Thus the plugin/ files ideally only contain the setup and user interface.
170 | 
171 | - If you need configurations try binding a global dict the user can set in its
172 |   .vimrc to a short buffer local var. Set settings if they have not been set by
173 |   the user. An example can be seen in autoload/vim_dev_plugin.vim which allows
174 |   the user to overwrite vim_scan_func in his .vimrc in this way:
175 |   let g:vim_dev = { 'vim_scan_func' : ... }
176 | 
177 | - If you want to let the user set configurations but provide defaults first
178 |   put all your setup code into an autoload function setting up defaults. Example:
179 | 
180 |   plugin/foo.vim:
181 |     call foo_setup#Setup()
182 | 
183 |   autoload/foo_setup.vim:
184 |     let s:did_setup = 0
185 |     fun! foo_setup#Setup()
186 |       " do this once only:
187 |       if s:did_setup | return | endif
188 |       let s:did_setup = 1
189 | 
190 |       setup mappings etc
191 |     endf
192 | 
193 | 
194 |   Then user or other plugins can patch anywhere (.vimrc, au commands):
195 | 
196 |   call foo_setup#Setup()
197 |   " do the patching
198 | 


--------------------------------------------------------------------------------
/addon-info.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name" : "vim-dev",
 3 |   "version" : "0.1",
 4 |   "author" : "Marc Weber <marco-oweber@gmx.de> and Cornelius Howl <cornelius.howl@gmail.com>",
 5 |   "maintainer" : "see author",
 6 |   "repository" : {"type": "git", "url": "git://github.com/c9s/vim-dev-plugin.git"},
 7 |   "dependencies" : {
 8 |     "tlib": {},
 9 |     "vim-addon-mw-utils": {},
10 |     "vim-addon-completion": {},
11 |     "vim-addon-goto-thing-at-cursor": {}
12 |   },
13 |   "description" : "vim omni completion and more"
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/autoload/vim_dev_plugin.vim:
--------------------------------------------------------------------------------
   1 | " vim:fdm=marker:
   2 | " Plugin:  Vim Omni Completion
   3 | " Version: 0.22
   4 | " Author:  Cornelius (林佑安)
   5 | " Contributor: Marc Weber (marco-oweber@gmx.de)
   6 | " Email:   cornelius.howl@gmail.com
   7 | 
   8 | if !exists('g:vim_dev') | let g:vim_dev = {} | endif | let s:c = g:vim_dev 
   9 | let s:c['vim_scan_func'] = get(s:c, 'vim_scan_func', {'func' : funcref#Function('vim_dev_plugin#ScanFunc'), 'version': 11, 'use_file_cache':1} )
  10 | 
  11 | let s:debug = 0
  12 | 
  13 | " builtin function {{{
  14 | " let s:builtin_function_list =  [
  15 | "     \"abs(", "add(", "append(", "argc(", "argidx(",
  16 | "     \"argv(", "atan(", "browse(", "browsedir(", "bufexists(", "buflisted(", "bufloaded(",
  17 | "     \"bufname(", "bufnr(", "bufwinnr(", "byte2line(", "byteidx(", "call(", "ceil(",
  18 | "     \"changenr(", "char2nr(", "cindent(", "clearmatches(", "col(", "complete(",
  19 | "     \"complete_add(", "complete_check(", "confirm(", "copy(", "cos(", "count(",
  20 | "     \"cscope_connection(", "cursor(", "deepcopy(", "delete(", "did_filetype(",
  21 | "     \"diff_filler(", "diff_hlID(", "empty(", "escape(", "eval(", "eventhandler(",
  22 | "     \"executable(", "exists(", "expand(", "extend(", "feedkeys(", "filereadable(",
  23 | "     \"filewritable(", "filter(", "finddir(", "findfile(", "float2nr(", "floor(",
  24 | "     \"fnameescape(", "fnamemodify(", "foldclosed(", "foldclosedend(", "foldlevel(",
  25 | "     \"foldtext(", "foldtextresult(", "foreground(", "function(", "garbagecollect(",
  26 | "     \"get(", "getbufline(", "getbufvar(", "getchar(", "getcharmod(", "getcmdline(",
  27 | "     \"getcmdpos(", "getcmdtype(", "getcwd(", "getfontname(", "getfperm(", "getfsize(",
  28 | "     \"getftime(", "getftype(", "getline(", "getloclist(", "getmatches(", "getpid(",
  29 | "     \"getpos(", "getqflist(", "getreg(", "getregtype(", "gettabwinvar(", "getwinposx(",
  30 | "     \"getwinposy(", "getwinvar(", "glob(", "globpath(", "has(", "has_key(",
  31 | "     \"haslocaldir(", "hasmapto(", "histadd(", "histdel(", "histget(", "histnr(", "hlID(",
  32 | "     \"hlexists(", "hostname(", "iconv(", "indent(", "index(", "input(", "inputdialog(",
  33 | "     \"inputlist(", "inputrestore(", "inputsave(", "inputsecret(", "insert(",
  34 | "     \"isdirectory(", "islocked(", "items(", "join(", "keys(", "len(", "libcall(",
  35 | "     \"libcallnr(", "line(", "line2byte(", "lispindent(", "localtime(", "log10(", "map(",
  36 | "     \"maparg(", "mapcheck(", "match(", "matchadd(", "matcharg(", "matchdelete(",
  37 | "     \"matchend(", "matchlist(", "matchstr(", "max(", "min(", "mkdir(", "mode(",
  38 | "     \"nextnonblank(", "nr2char(", "pathshorten(", "pow(", "prevnonblank(", "printf(",
  39 | "     \"pumvisible(", "range(", "readfile(", "reltime(", "reltimestr(", "remote_expr(",
  40 | "     \"remote_foreground(", "remote_peek(", "remote_read(", "remote_send(", "remove(",
  41 | "     \"rename(", "repeat(", "resolve(", "reverse(", "round(", "search(", "searchdecl(",
  42 | "     \"searchpair(", "searchpairpos(", "searchpos(", "server2client(", "serverlist(",
  43 | "     \"setbufvar(", "setcmdpos(", "setline(", "setloclist(", "setmatches(", "setpos(",
  44 | "     \"setqflist(", "setreg(", "settabwinvar(", "setwinvar(", "shellescape(", "simplify(",
  45 | "     \"sin(", "sort(", "soundfold(", "spellbadword(", "spellsuggest(", "split(", "sqrt(",
  46 | "     \"str2float(", "str2nr(", "strftime(", "stridx(", "string(", "strlen(", "strpart(",
  47 | "     \"strridx(", "strtrans(", "submatch(", "substitute(", "synID(", "synIDattr(",
  48 | "     \"synIDtrans(", "synstack(", "system(", "tabpagebuflist(", "tabpagenr(",
  49 | "     \"tabpagewinnr(", "tagfiles(", "taglist(", "tempname(", "tolower(", "toupper(", "tr(",
  50 | "     \"trunc(", "type(", "values(", "virtcol(", "visualmode(", "winbufnr(", "wincol(",
  51 | "     \"winheight(", "winline(", "winnr(", "winrestcmd(", "winrestview(", "winsaveview(",
  52 | "     \"winwidth(", "writefile("]"}}}
  53 | " builtin commands {{{
  54 | let s:builtin_command_list = [
  55 |       \"abclear", "argdo", "argument", "belowright",
  56 |       \"bNext", "breakdel", "buffer", "caddbuffer", "cbuffer", "cexpr", "cgetfile",
  57 |       \"checktime", "cnewer", "colder", "continue", "cquit", "delcommand", "diffoff",
  58 |       \"diffupdate", "drop", "echomsg", "emenu", "endtry", "exusage", "find",
  59 |       \"foldclose", "function", "hardcopy", "helptags", "if", "isearch", "jumps",
  60 |       \"keepmarks", "language", "lcd", "leftabove", "lgetbuffer", "lgrepadd",
  61 |       \"llast", "lmapclear", "lnfile", "lockmarks", "lpfile", "ltag", "make",
  62 |       \"menutranslate", "mkview", "mzfile", "next", "number", "options", "perldo",
  63 |       \"ppop", "Print", "promptrepl", "ptjump", "ptprevious", "pwd", "quit", "redir",
  64 |       \"registers", "rewind", "rubydo", "sall", "sball", "sbnext", "sbuffer",
  65 |       \"setfiletype", "sfirst", "simalt", "smap", "snext", "snoremap", "source",
  66 |       \"spellrepall", "sprevious", "startinsert", "stopinsert", "sunmenu", "t",
  67 |       \"tabedit", "tabmove", "tabonly", "tag", "tclfile", "tjump", "tnext",
  68 |       \"trewind", "tunmenu", "undolist", "verbose", "vimgrep", "vmapclear", "while",
  69 |       \"winsize", "wq", "wviminfo", "xmap", "XMLent", "xnoremenu", "aboveleft",
  70 |       \"argedit", "ascii", "bfirst", "botright", "breaklist", "buffers", "caddexpr",
  71 |       \"cc", "cfile", "change", "clast", "cnext", "colorscheme", "copen", "crewind",
  72 |       \"delete", "diffpatch", "digraphs", "dsearch", "echon", "emenu*", "endwhile",
  73 |       \"file", "finish", "folddoclosed", "goto", "help", "hide", "ijump", "isplit",
  74 |       \"k", "laddbuffer", "last", "lchdir", "lexpr", "lgetexpr", "lhelpgrep",
  75 |       \"llist", "lnewer", "lNfile", "lockvar", "lprevious", "lvimgrep", "mark",
  76 |       \"mkexrc", "mkvimrc", "mzscheme", "Next", "omapclear", "pclose", "pop",
  77 |       \"preserve", "profdel", "psearch", "ptlast", "ptrewind", "pyfile", "quitall",
  78 |       \"redo", "resize", "right", "rubyfile", "sandbox", "sbfirst", "sbNext",
  79 |       \"scriptencoding", "setglobal", "shell", "slast", "smapclear", "sNext",
  80 |       \"snoreme", "spelldump", "spellundo", "srewind", "startreplace", "stselect",
  81 |       \"suspend", "tab", "tabfind", "tabnew", "tabprevious", "tags", "tearoff",
  82 |       \"tlast", "tNext", "try", "unabbreviate", "unhide", "version", "vimgrepadd",
  83 |       \"vnew", "wincmd", "wnext", "wqall", "X", "xmapclear", "XMLns", "xunme", "all",
  84 |       \"argglobal", "badd", "blast", "bprevious", "brewind", "bunload", "caddfile",
  85 |       \"cclose", "cfirst", "changes", "clist", "cNext", "comclear", "copy",
  86 |       \"cunabbrev", "delfunction", "diffput", "display", "dsplit", "edit", "endfor",
  87 |       \"enew", "files", "first", "folddoopen", "grep", "helpfind", "history",
  88 |       \"ilist", "iunabbrev", "keepalt", "laddexpr", "later", "lclose", "lfile",
  89 |       \"lgetfile", "list", "lmake", "lnext", "lnoremap", "lolder", "lrewind",
  90 |       \"lvimgrepadd", "marks", "mksession", "mode", "nbkey", "nmapclear", "only",
  91 |       \"pedit", "popu", "previous", "profile", "ptag", "ptnext", "ptselect",
  92 |       \"python", "read", "redraw", "retab", "rightbelow", "runtime", "sargument",
  93 |       \"sblast", "sbprevious", "scriptnames", "setlocal", "sign", "sleep", "sme",
  94 |       \"sniff", "snoremenu", "spellgood", "spellwrong", "stag", "stjump", "sunhide",
  95 |       \"sview", "tabclose", "tabfirst", "tabnext", "tabrewind", "tcl", "tfirst",
  96 |       \"tm", "topleft", "tselect", "undo", "unlockvar", "vertical", "visual",
  97 |       \"vsplit", "windo", "wNext", "write", "xall", "xme", "xnoremap", "xunmenu",
  98 |       \"argadd", "arglocal", "ball", "bmodified", "break", "browse", "bwipeout",
  99 |       \"call", "cd", "cgetbuffer", "chdir", "close", "cnfile", "compiler", "cpfile",
 100 |       \"cwindow", "delmarks", "diffsplit", "djump", "earlier", "else", "endfunction",
 101 |       \"ex", "filetype", "fixdel", "foldopen", "grepadd", "helpgrep", "iabclear",
 102 |       \"imapclear", "join", "keepjumps", "laddfile", "lbuffer", "left", "lfirst",
 103 |       \"lgrep", "ll", "lmap", "lNext", "loadview", "lopen", "ls", "lwindow", "match",
 104 |       \"mkspell", "move", "new", "nohlsearch", "open", "perl", "popup", "print",
 105 |       \"promptfind", "ptfirst", "ptNext", "put", "qall", "recover", "redrawstatus",
 106 |       \"return", "ruby", "rviminfo", "saveas", "sbmodified", "sbrewind", "set",
 107 |       \"sfind", "silent", "smagic", "smenu", "snomagic", "sort", "spellinfo",
 108 |       \"split", "startgreplace", "stop", "sunme", "syncbind", "tabdo", "tablast",
 109 |       \"tabNext", "tabs", "tcldo", "throw", "tmenu", "tprevious", "tu", "undojoin",
 110 |       \"update", "view", "viusage", "wall", "winpos", "wprevious", "wsverb", "xit",
 111 |       \"xmenu", "xnoreme", "yank", "argdelete", "args", "bdelete", "bnext",
 112 |       \"breakadd", "bufdo", "cabclear", "catch", "center", "cgetexpr", "checkpath",
 113 |       \"cmapclear", "cNfile", "confirm", "cprevious", "debuggreedy", "diffget",
 114 |       \"diffthis", "dlist", "echoerr", "elseif", "endif", "exit", "finally", "fold",
 115 |       \"for" ]
 116 | "}}}
 117 | " options {{{
 118 | " TODO: complete vim_dev_plugin#OptionList() and use its result instead
 119 | let s:builtin_option_list = [
 120 |       \"acd", "ambiwidth", "arabicshape",
 121 |       \"autowriteall", "backupdir", "bdlay", "binary", "breakat", "bufhidden",
 122 |       \"cdpath", "cin", "cinwords", "columns", "completeopt", "cpo",
 123 |       \"cscopetagorder", "csverb", "deco", "dictionary", "directory", "ed",
 124 |       \"encoding", "errorfile", "exrc", "fdls", "fencs", "fileformats", "fmr",
 125 |       \"foldlevel", "foldtext", "fsync", "gfs", "gtl", "guioptions", "hf", "hk",
 126 |       \"hlsearch", "imak", "ims", "indentexpr", "is", "isp", "keywordprg",
 127 |       \"lazyredraw", "lispwords", "ls", "makeef", "maxmapdepth", "mfd", "mmd",
 128 |       \"modified", "mousemodel", "msm", "numberwidth", "operatorfunc", "pastetoggle",
 129 |       \"pexpr", "pmbfn", "printexpr", "pt", "readonly", "rightleft", "rtp", "sb",
 130 |       \"scroll", "sect", "sessionoptions", "shellpipe", "shellxquote", "showbreak",
 131 |       \"shq", "slm", "smd", "spc", "spf", "sr", "sta", "sts", "swapfile", "sxq",
 132 |       \"tabpagemax", "tags", "tbis", "terse", "thesaurus", "titleold",
 133 |       \"toolbariconsize", "tsr", "ttyfast", "tx", "ut", "verbosefile", "virtualedit",
 134 |       \"wb", "wfw", "wildcharm", "winaltkeys", "winminwidth", "wmnu", "write",
 135 |       \"ai", "ambw", "ari", "aw", "backupext", "beval", "biosk", "brk", "buflisted",
 136 |       \"cedit", "cindent", "clipboard", "com", "confirm", "cpoptions",
 137 |       \"cscopeverbose", "cuc", "def", "diff", "display", "edcompatible", "endofline",
 138 |       \"errorformat", "fcl", "fdm", "fex", "filetype", "fo", "foldlevelstart",
 139 |       \"formatexpr", "ft", "gfw", "gtt", "guipty", "hh", "hkmap", "ic", "imc",
 140 |       \"imsearch", "indentkeys", "isf", "isprint", "km", "lbr", "list", "lsp",
 141 |       \"makeprg", "maxmem", "mh", "mmp", "more", "mouses", "mzq", "nuw", "opfunc",
 142 |       \"patchexpr", "pfn", "popt", "printfont", "pumheight", "redrawtime",
 143 |       \"rightleftcmd", "ru", "sbo", "scrollbind", "sections", "sft", "shellquote",
 144 |       \"shiftround", "showcmd", "si", "sm", "sn", "spell", "spl", "srr", "stal",
 145 |       \"su", "swapsync", "syn", "tabstop", "tagstack", "tbs", "textauto", "tildeop",
 146 |       \"titlestring", "top", "ttimeout", "ttym", "uc", "vb", "vfile", "visualbell",
 147 |       \"wc", "wh", "wildignore", "window", "winwidth", "wmw", "writeany",
 148 |       \"anti", "arshape", "awa", "backupskip", "bex", "bioskey", "browsedir",
 149 |       \"buftype", "cf", "cink", "cmdheight", "comments", "consk", "cpt", "cspc",
 150 |       \"cul", "define", "diffexpr", "dy", "ef", "eol", "esckeys", "fcs", "fdn",
 151 |       \"ff", "fillchars", "foldclose", "foldmarker", "formatlistpat", "gcr", "ghr",
 152 |       \"guicursor", "guitablabel", "hi", "hkmapp", "icon", "imcmdline", "inc",
 153 |       \"indk", "isfname", "joinspaces", "kmp", "lcs", "listchars", "lw", "mat",
 154 |       \"maxmempattern", "mis", "mmt", "mouse", "mouseshape", "mzquantum", "odev",
 155 |       \"osfiletype", "patchmode", "ph", "preserveindent", "printheader", "pvh",
 156 |       \"remap", "rl", "ruf", "sbr", "scrolljump", "secure", "sh", "shellredir",
 157 |       \"shiftwidth", "showfulltag", "sidescroll", "smartcase", "so", "spellcapcheck",
 158 |       \"splitbelow", "ss", "startofline", "sua", "swb", "synmaxcol", "tag", "tal",
 159 |       \"tenc", "textmode", "timeout", "tl", "tpm", "ttimeoutlen", "ttymouse", "ul",
 160 |       \"vbs", "vi", "vop", "wcm", "whichwrap", "wildmenu", "winfixheight", "wiv",
 161 |       \"wop", "writebackup", "al", "antialias", "autochdir", "background",
 162 |       \"balloondelay", "bexpr", "bk", "bs", "casemap", "cfu", "cinkeys",
 163 |       \"cmdwinheight", "commentstring", "conskey", "cscopepathcomp", "csprg",
 164 |       \"cursorcolumn", "delcombine", "diffopt", "ea", "efm", "ep", "et", "fdc",
 165 |       \"fdo", "ffs", "fk", "foldcolumn", "foldmethod", "formatoptions", "gd", "go",
 166 |       \"guifont", "guitabtooltip", "hid", "hkp", "iconstring", "imd", "include",
 167 |       \"inex", "isi", "js", "kp", "linebreak", "lm", "lz", "matchpairs", "maxmemtot",
 168 |       \"mkspellmem", "mod", "mousef", "mouset", "nf", "oft", "pa", "path",
 169 |       \"pheader", "previewheight", "printmbcharset", "pvw", "report", "rlc", "ruler",
 170 |       \"sc", "scrolloff", "sel", "shcf", "shellslash", "shm", "showmatch",
 171 |       \"sidescrolloff", "smartindent", "softtabstop", "spellfile", "splitright",
 172 |       \"ssl", "statusline", "suffixes", "swf", "syntax", "tagbsearch", "tb", "term",
 173 |       \"textwidth", "timeoutlen", "tm", "tr", "ttm", "ttyscroll", "undolevels",
 174 |       \"vdir", "viewdir", "wa", "wd", "wi", "wildmode", "winfixwidth", "wiw",
 175 |       \"wrap", "writedelay", "ar", "autoindent", "backspace", "ballooneval",
 176 |       \"bg", "bkc", "bsdir", "cb", "ch", "cino", "cmp", "compatible", "copyindent",
 177 |       \"cscopeprg", "csqf", "cursorline", "dex", "digraph", "ead", "ei",
 178 |       \"equalalways", "eventignore", "fde", "fdt", "fileencoding", "fkmap",
 179 |       \"foldenable", "foldminlines", "formatprg", "gdefault", "gp", "guifontset",
 180 |       \"helpfile", "hidden", "hl", "ignorecase", "imdisable", "includeexpr", "inf",
 181 |       \"isident", "key", "langmap", "lines", "lmap", "ma", "matchtime", "mco", "ml",
 182 |       \"modeline", "mousefocus", "mousetime", "nrformats", "ofu", "para", "pdev",
 183 |       \"pi", "previewwindow", "printmbfont", "qe", "restorescreen", "ro",
 184 |       \"rulerformat", "scb", "scrollopt", "selection", "shell", "shelltemp",
 185 |       \"shortmess", "showmode", "siso", "smarttab", "sol", "spelllang", "spr",
 186 |       \"ssop", "stl", "suffixesadd", "switchbuf", "ta", "taglength", "tbi",
 187 |       \"termbidi", "tf", "title", "to", "ts", "tty", "ttytype", "updatecount", "ve",
 188 |       \"viewoptions", "wak", "weirdinvert", "wig", "wildoptions", "winheight", "wm",
 189 |       \"wrapmargin", "ws", "arab", "autoread", "backup", "balloonexpr",
 190 |       \"bh", "bl", "bsk", "ccv", "charconvert", "cinoptions", "cms", "complete",
 191 |       \"cot", "cscopequickfix", "cst", "cwh", "dg", "dip", "eadirection", "ek",
 192 |       \"equalprg", "ex", "fdi", "fen", "fileencodings", "flp", "foldexpr",
 193 |       \"foldnestmax", "fp", "gfm", "grepformat", "guifontwide", "helpheight",
 194 |       \"highlight", "hlg", "im", "imi", "incsearch", "infercase", "isk", "keymap",
 195 |       \"langmenu", "linespace", "loadplugins", "macatsui", "maxcombine", "mef",
 196 |       \"mls", "modelines", "mousehide", "mp", "nu", "omnifunc", "paragraphs",
 197 |       \"penc", "pm", "printdevice", "printoptions", "quoteescape", "revins", "rs",
 198 |       \"runtimepath", "scr", "scs", "selectmode", "shellcmdflag", "shelltype",
 199 |       \"shortname", "showtabline", "sj", "smc", "sp", "spellsuggest", "sps", "st",
 200 |       \"stmp", "sw", "sws", "tabline", "tagrelative", "tbidi", "termencoding",
 201 |       \"tgst", "titlelen", "toolbar", "tsl", "ttybuiltin", "tw", "updatetime",
 202 |       \"verbose", "viminfo", "warn", "wfh", "wildchar", "wim", "winminheight",
 203 |       \"wmh", "wrapscan", "ww", "altkeymap", "arabic", "autowrite", "backupcopy",
 204 |       \"bdir", "bin", "bomb", "bt", "cd", "ci", "cinw", "co", "completefunc", "cp",
 205 |       \"cscopetag", "csto", "debug", "dict", "dir", "eb", "enc", "errorbells",
 206 |       \"expandtab", "fdl", "fenc", "fileformat", "fml", "foldignore", "foldopen",
 207 |       \"fs", "gfn", "grepprg", "guiheadroom", "helplang", "history", "hls",
 208 |       \"imactivatekey", "iminsert", "inde", "insertmode", "iskeyword", "keymodel",
 209 |       \"laststatus", "lisp", "lpl", "magic", "maxfuncdepth", "menuitems", "mm",
 210 |       \"modifiable", "mousem", "mps", "number", "opendevice", "paste", "pex",
 211 |       \"pmbcs", "printencoding", "prompt", "rdt", "ri", "noacd", "noallowrevins",
 212 |       \"noantialias", "noarabic", "noarshape", "noautoread", "noaw",
 213 |       \"noballooneval", "nobinary", "nobk", "nobuflisted", "nocin", "noconfirm",
 214 |       \"nocopyindent", "nocscopeverbose", "nocuc", "nocursorline", "nodg",
 215 |       \"nodisable", "noeb", "noedcompatible", "noendofline", "noequalalways",
 216 |       \"noesckeys", "noex", "noexrc", "nofk", "nofoldenable", "nogdefault", "nohid",
 217 |       \"nohk", "nohkmapp", "nohls", "noic", "noignorecase", "noimc", "noimd",
 218 |       \"noinf", "noinsertmode", "nojoinspaces", "nolazyredraw", "nolinebreak",
 219 |       \"nolist", "nolpl", "noma", "nomagic", "noml", "nomodeline", "nomodified",
 220 |       \"nomousef", "nomousehide", "nonumber", "noopendevice", "nopi",
 221 |       \"nopreviewwindow", "nopvw", "noremap", "norevins", "norightleft", "norl",
 222 |       \"noro", "noru", "nosb", "noscb", "noscs", "nosft", "noshelltemp",
 223 |       \"noshortname", "noshowfulltag", "noshowmode", "nosm", "nosmartindent",
 224 |       \"nosmd", "nosol", "nosplitbelow", "nospr", "nossl", "nostartofline",
 225 |       \"noswapfile", "nota", "notagrelative", "notbi", "notbs", "noterse",
 226 |       \"notextmode", "notgst", "notimeout", "noto", "notr", "nottybuiltin", "notx",
 227 |       \"novisualbell", "nowarn", "noweirdinvert", "nowfw", "nowinfixheight", "nowiv",
 228 |       \"nowrap", "nowrite", "nowritebackup", "noai", "noaltkeymap", "noar",
 229 |       \"noarabicshape", "noautochdir", "noautowrite", "noawa", "nobeval", "nobiosk",
 230 |       \"nobl", "nocf", "nocindent", "noconsk", "nocp", "nocst", "nocul", "nodeco",
 231 |       \"nodiff", "noea", "noed", "noek", "noeol", "noerrorbells", "noet",
 232 |       \"noexpandtab", "nofen", "nofkmap", "nogd", "noguipty", "nohidden", "nohkmap",
 233 |       \"nohkp", "nohlsearch", "noicon", "noim", "noimcmdline", "noincsearch",
 234 |       \"noinfercase", "nois", "nojs", "nolbr", "nolisp", "noloadplugins", "nolz",
 235 |       \"nomacatsui", "nomh", "nomod", "nomodifiable", "nomore", "nomousefocus",
 236 |       \"nonu", "noodev", "nopaste", "nopreserveindent", "noprompt", "noreadonly",
 237 |       \"norestorescreen", "nori", "norightleftcmd", "norlc", "nors", "noruler",
 238 |       \"nosc", "noscrollbind", "nosecure", "noshellslash", "noshiftround",
 239 |       \"noshowcmd", "noshowmatch", "nosi", "nosmartcase", "nosmarttab", "nosn",
 240 |       \"nospell", "nosplitright", "nosr", "nosta", "nostmp", "noswf",
 241 |       \"notagbsearch", "notagstack", "notbidi", "notermbidi", "notextauto", "notf",
 242 |       \"notildeop", "notitle", "notop", "nottimeout", "nottyfast", "novb", "nowa",
 243 |       \"nowb", "nowfh", "nowildmenu", "nowinfixwidth", "nowmnu", "nowrapscan",
 244 |       \"nowriteany", "nows" ,"noakm", "noanti", "noarab", "noari", "noautoindent",
 245 |       \"noautowriteall", "nobackup", "nobin", "nobioskey", "nobomb", "noci",
 246 |       \"nocompatible", "noconskey", "nocscopetag", "nocsverb", "nocursorcolumn",
 247 |       \"nodelcombine", "nodigraph", "invacd", "invallowrevins", "invantialias",
 248 |       \"invarabic", "invarshape", "invautoread", "invaw", "invballooneval",
 249 |       \"invbinary", "invbk", "invbuflisted", "invcin", "invconfirm", "invcopyindent",
 250 |       \"invcscopeverbose", "invcuc", "invcursorline", "invdg", "invdisable",
 251 |       \"inveb", "invedcompatible", "invendofline", "invequalalways", "invesckeys",
 252 |       \"invex", "invexrc", "invfk", "invfoldenable", "invgdefault", "invhid",
 253 |       \"invhk", "invhkmapp", "invhls", "invic", "invignorecase", "invimc", "invimd",
 254 |       \"invinf", "invinsertmode", "invjoinspaces", "invlazyredraw", "invlinebreak",
 255 |       \"invlist", "invlpl", "invma", "invmagic", "invml", "invmodeline",
 256 |       \"invmodified", "invmousef", "invmousehide", "invnumber", "invopendevice",
 257 |       \"invpi", "invpreviewwindow", "invpvw", "invremap", "invrevins",
 258 |       \"invrightleft", "invrl", "invro", "invru", "invsb", "invscb", "invscs",
 259 |       \"invsft", "invshelltemp", "invshortname", "invshowfulltag", "invshowmode",
 260 |       \"invsm", "invsmartindent", "invsmd", "invsol", "invsplitbelow", "invspr",
 261 |       \"invssl", "invstartofline", "invswapfile", "invta", "invtagrelative",
 262 |       \"invtbi", "invtbs", "invterse", "invtextmode", "invtgst", "invtimeout",
 263 |       \"invto", "invtr", "invttybuiltin", "invtx", "invvisualbell", "invwarn",
 264 |       \"invweirdinvert", "invwfw", "invwinfixheight", "invwiv", "invwrap",
 265 |       \"invwrite", "invwritebackup", "invai", "invaltkeymap", "invar",
 266 |       \"invarabicshape", "invautochdir", "invautowrite", "invawa", "invbeval",
 267 |       \"invbiosk", "invbl", "invcf", "invcindent", "invconsk", "invcp", "invcst",
 268 |       \"invcul", "invdeco", "invdiff", "invea", "inved", "invek", "inveol",
 269 |       \"inverrorbells", "invet", "invexpandtab", "invfen", "invfkmap", "invgd",
 270 |       \"invguipty", "invhidden", "invhkmap", "invhkp", "invhlsearch", "invicon",
 271 |       \"invim", "invimcmdline", "invincsearch", "invinfercase", "invis", "invjs",
 272 |       \"invlbr", "invlisp", "invloadplugins", "invlz", "invmacatsui", "invmh",
 273 |       \"invmod", "invmodifiable", "invmore", "invmousefocus", "invnu", "invodev",
 274 |       \"invpaste", "invpreserveindent", "invprompt", "invreadonly",
 275 |       \"invrestorescreen", "invri", "invrightleftcmd", "invrlc", "invrs", "invruler",
 276 |       \"invsc", "invscrollbind", "invsecure", "invshellslash", "invshiftround",
 277 |       \"invshowcmd", "invshowmatch", "invsi", "invsmartcase", "invsmarttab", "invsn",
 278 |       \"invspell", "invsplitright", "invsr", "invsta", "invstmp", "invswf",
 279 |       \"invtagbsearch", "invtagstack", "invtbidi", "invtermbidi", "invtextauto",
 280 |       \"invtf", "invtildeop", "invtitle", "invtop", "invttimeout", "invttyfast",
 281 |       \"invvb", "invwa", "invwb", "invwfh", "invwildmenu", "invwinfixwidth",
 282 |       \"invwmnu", "invwrapscan", "invwriteany", "invws", "invakm", "invanti",
 283 |       \"invarab", "invari", "invautoindent", "invautowriteall", "invbackup",
 284 |       \"invbin", "invbioskey", "invbomb", "invci", "invcompatible", "invconskey",
 285 |       \"invcscopetag", "invcsverb", "invcursorcolumn", "invdelcombine", "invdigraph",
 286 |       \"t_AB", "t_al", "t_bc", "t_ce", "t_cl", "t_Co", "t_cs", "t_Cs", "t_CS",
 287 |       \"t_CV", "t_da", "t_db", "t_dl", "t_DL", "t_EI", "t_F1", "t_F2", "t_F3",
 288 |       \"t_F4", "t_F5", "t_F6", "t_F7", "t_F8", "t_F9", "t_fs", "t_IE", "t_IS",
 289 |       \"t_k1", "t_K1", "t_k2", "t_k3", "t_K3", "t_k4", "t_K4", "t_k5", "t_K5",
 290 |       \"t_k6", "t_K6", "t_k7", "t_K7", "t_k8", "t_K8", "t_k9", "t_K9", "t_KA",
 291 |       \"t_kb", "t_kB", "t_KB", "t_KC", "t_kd", "t_kD", "t_KD", "t_ke", "t_KE",
 292 |       \"t_KF", "t_KG", "t_kh", "t_KH", "t_kI", "t_KI", "t_KJ", "t_KK", "t_kl",
 293 |       \"t_KL", "t_kN", "t_kP", "t_kr", "t_ks", "t_ku", "t_le", "t_mb", "t_md",
 294 |       \"t_me", "t_mr", "t_ms", "t_nd", "t_op", "t_RI", "t_RV", "t_Sb", "t_se",
 295 |       \"t_Sf", "t_SI", "t_so", "t_sr", "t_te", "t_ti", "t_ts", "t_ue", "t_us",
 296 |       \"t_ut", "t_vb", "t_ve", "t_vi", "t_vs", "t_WP", "t_WS", "t_xs", "t_ZH", "t_ZR",
 297 |       \"t_AF", "t_AL", "t_cd", "t_Ce", "t_cm"]
 298 | "}}}
 299 | 
 300 | let s:mapargments = [ "<buffer>", "<silent>", "<special>", "<script>", "<expr>","<unique>" ]
 301 | 
 302 | " features {{{
 303 | let s:features = [
 304 |   \"all_builtin_terms", "amiga", "arabic", "arp", "autocmd",
 305 |   \"balloon_eval", "balloon_multiline", "beos", "browse", "builtin_terms",
 306 |   \"byte_offset", "cindent", "clientserver", "clipboard", "cmdline_compl",
 307 |   \"cmdline_hist", "cmdline_info", "comments", "cryptv", "cscope", "compatible",
 308 |   \"debug", "dialog_con", "dialog_gui", "diff", "digraphs", "dnd", "dos32",
 309 |   \"dos16", "ebcdic", "emacs_tags", "eval", "ex_extra", "extra_search", "farsi",
 310 |   \"file_in_path", "filterpipe", "find_in_path", "float", "fname_case",
 311 |   \"folding", "footer", "fork", "gettext", "gui", "gui_athena", "gui_gtk",
 312 |   \"gui_gtk2", "gui_gnome", "gui_mac", "gui_motif", "gui_photon", "gui_win32",
 313 |   \"gui_win32s", "gui_running", "hangul_input", "iconv", "insert_expand",
 314 |   \"jumplist", "keymap", "langmap", "libcall", "linebreak", "lispindent",
 315 |   \"listcmds", "localmap", "mac", "macunix", "menu", "mksession", "modify_fname",
 316 |   \"mouse", "mouseshape", "mouse_dec", "mouse_gpm", "mouse_netterm",
 317 |   \"mouse_pterm", "mouse_sysmouse", "mouse_xterm", "multi_byte",
 318 |   \"multi_byte_encoding", "multi_byte_ime", "multi_lang", "mzscheme",
 319 |   \"netbeans_intg", "netbeans_enabled", "ole", "os2", "osfiletype", "path_extra",
 320 |   \"perl", "postscript", "printer", "profile", "python", "qnx", "quickfix",
 321 |   \"reltime", "rightleft", "ruby", "scrollbind", "showcmd", "signs",
 322 |   \"smartindent", "sniff", "startuptime", "statusline", "sun_workshop", "spell",
 323 |   \"syntax", "syntax_items", "system", "tag_binary", "tag_old_static",
 324 |   \"tag_any_white", "tcl", "terminfo", "termresponse", "textobjects", "tgetent",
 325 |   \"title", "toolbar", "unix", "user_commands", "viminfo", "vim_starting",
 326 |   \"vertsplit", "virtualedit", "visual", "visualextra", "vms", "vreplace",
 327 |   \"wildignore", "wildmenu", "windows", "winaltkeys", "win16", "win32", "win64",
 328 |   \"win32unix", "win95", "writebackup", "xfontset", "xim", "xsmp",
 329 |   \"xsmp_interact", "xterm_clipboard", "xterm_save", "\x11" ]
 330 | "}}}
 331 | 
 332 | let s:command_attr = [ 
 333 |       \'-range',
 334 |       \'-range=%',
 335 |       \'-range=',
 336 |       \'-count=',
 337 |       \'-bang',
 338 |       \'-bar',
 339 |       \'-register',
 340 |       \'-buffer',
 341 |       \'-nargs=0',
 342 |       \'-nargs=1',
 343 |       \'-nargs=*',
 344 |       \'-nargs=?',
 345 |       \'-nargs=+']
 346 | 
 347 | let s:command_complete = [
 348 |     \'-complete=',	
 349 |     \'-complete=augroup',	
 350 |     \'-complete=buffer',	
 351 |     \'-complete=command',	
 352 |     \'-complete=dir',		
 353 |     \'-complete=environment',	
 354 |     \'-complete=event',		
 355 |     \'-complete=expression',	
 356 |     \'-complete=file',		
 357 |     \'-complete=shellcmd',	
 358 |     \'-complete=function',	
 359 |     \'-complete=help',		
 360 |     \'-complete=highlight',	
 361 |     \'-complete=mapping',	
 362 |     \'-complete=menu',		
 363 |     \'-complete=option',	
 364 |     \'-complete=tag',		
 365 |     \'-complete=tag_listfiles',	
 366 |     \'-complete=var',		
 367 |     \'-complete=custom,',
 368 |     \'-complete=customlist,']
 369 | 
 370 | " autocmd {{{
 371 | let s:autocmd_events = [
 372 |   \"BufNewFile", "BufReadPre", "BufRead", "BufReadPost", "BufReadCmd",
 373 |   \"FileReadPre", "FileReadPost", "FileReadCmd", "FilterReadPre",
 374 |   \"FilterReadPost", "StdinReadPre", "StdinReadPost", "BufWrite", "BufWritePre",
 375 |   \"BufWritePost", "BufWriteCmd", "FileWritePre", "FileWritePost",
 376 |   \"FileWriteCmd", "FileAppendPre", "FileAppendPost", "FileAppendCmd",
 377 |   \"FilterWritePre", "FilterWritePost", "BufAdd", "BufCreate", "BufDelete",
 378 |   \"BufWipeout", "BufFilePre", "BufFilePost", "BufEnter", "BufLeave",
 379 |   \"BufWinEnter", "BufWinLeave", "BufUnload", "BufHidden", "BufNew",
 380 |   \"SwapExists", "FileType", "Syntax", "EncodingChanged", "TermChanged",
 381 |   \"VimEnter", "GUIEnter", "TermResponse", "VimLeavePre", "VimLeave",
 382 |   \"FileChangedShell", "FileChangedShellPost", "FileChangedRO", "ShellCmdPost",
 383 |   \"ShellFilterPost", "FuncUndefined", "SpellFileMissing", "SourcePre",
 384 |   \"SourceCmd", "VimResized", "FocusGained", "FocusLost", "CursorHold",
 385 |   \"CursorHoldI", "CursorMoved", "CursorMovedI", "WinEnter", "WinLeave",
 386 |   \"TabEnter", "TabLeave", "CmdwinEnter", "CmdwinLeave", "InsertEnter",
 387 |   \"InsertChange", "InsertLeave", "ColorScheme", "RemoteReply", "QuickFixCmdPre",
 388 |   \"QuickFixCmdPost", "SessionLoadPost", "MenuPopup", "User" ]
 389 | "}}}
 390 | " Cache Functions {{{
 391 | fun! GetCache(key)
 392 |   if exists('g:__cache_' . a:key )
 393 |     return g:__cache_{a:key}
 394 |   else
 395 |     return -1
 396 |   endif
 397 | endf
 398 | 
 399 | fun! s:Matches(s)
 400 |   return a:s =~ s:base || ( s:additional_regex != "" && a:s =~ s:additional_regex)
 401 | endf
 402 | 
 403 | fun! SetCache(key,val)
 404 |   let g:__cache_{a:key} = a:val
 405 | endf
 406 | "}}}
 407 | fun! vim_dev_plugin#VimOmniComplete(findstart, base) "{{{
 408 |   if a:findstart
 409 |     let start = col('.') - 1
 410 |     let line = getline('.')
 411 |     while start > 0 && line[start - 1] =~ '[a-zA-Z-_#.0-9]' 
 412 |       let start -= 1
 413 |     endwhile
 414 | 
 415 |     " b: g: s: v: prefix?
 416 |     let b:prefix_completion =
 417 |           \ (start >= 2 && line[start-1] == ':')
 418 |             \ ? line[start-2]
 419 |             \ : ""
 420 | 
 421 |     if (start >= 1 && line[start -1] == '&')
 422 |       let b:prefix_completion = '&'
 423 |     endif
 424 | 
 425 |     let b:context = strpart( getline('.') , 0 , start + 1 )
 426 |     let b:tokens  = split(b:context,'\s\+')
 427 | 
 428 |     if b:context =~ '-complete=$'
 429 |       return col('.') - strlen('-complete=') - 1
 430 |     endif
 431 | 
 432 |     return start
 433 | 
 434 |     " for b: g: s: completion base starts after ':' !
 435 | 
 436 |   else
 437 | 
 438 |     let b:scanned_buf = vim_dev_plugin#ScanFuncLines(getline(1, line('$')), 'current file')
 439 | 
 440 |     let b:g_prefix = b:prefix_completion == 'g'
 441 | 
 442 |     let patterns = vim_addon_completion#AdditionalCompletionMatchPatterns(a:base
 443 |           \ , "vim_dev_plugin_completion_func", {'match_beginning_of_string': 0})
 444 |     " binding to local var so that I don't have to pass them again and again
 445 |     " See s:Matches
 446 |     let s:additional_regex = get(patterns, 'vim_regex', "")
 447 |     let s:base = a:base
 448 | 
 449 |     " a: completion
 450 |     if b:prefix_completion == 'a'
 451 |       call vim_dev_plugin#ACompletion()
 452 |       return []
 453 |     endif
 454 | 
 455 |     " v: completion
 456 |     if b:prefix_completion == 'v'
 457 |       call vim_dev_plugin#VCompletion()
 458 |       return []
 459 |     endif
 460 | 
 461 |     " s:completion
 462 |     if b:prefix_completion == 's'
 463 |       call vim_dev_plugin#SCompletion()
 464 |       return []
 465 |     endif
 466 | 
 467 |     " b:completion
 468 |     if b:prefix_completion == 'b'
 469 |       call vim_dev_plugin#BCompletion()
 470 |       return []
 471 |     endif
 472 | 
 473 |     " &completion
 474 |     if b:prefix_completion == '&'
 475 |       " TODO use vim_dev_plugin#OptionList with description - but its
 476 |       for x in vim_dev_plugin#OptionList()
 477 |         if s:Matches(x.long)  | call complete_add({'word': x.long, 'menu': x.description[0], 'info': x.description}) | endif
 478 |         if s:Matches(x.short) | call complete_add({'word': x.short, 'menu': split(x.description,"\n")[0], 'info': x.description}) | endif
 479 |       endfor
 480 |       return []
 481 |     endif
 482 | 
 483 |     if b:prefix_completion == ""
 484 |       " this is fast, so add these completions early
 485 |       call vim_dev_plugin#CompleteFunLocalLets()
 486 |     endif
 487 | 
 488 |     " g:completion
 489 |     if b:prefix_completion == 'g'
 490 |       call vim_dev_plugin#GCompletion()
 491 |       " use return? does the code below add more g: items?
 492 |       " also add dynamic g: vars?
 493 |       " TODO
 494 |     endif
 495 | 
 496 |     let comps = [ ]
 497 |     let lines = getline(1,'$')
 498 |     let f_ptn =  '\(^\s*fun[ction]*!\?\s\+\)\@<=\([sgb]:[a-zA-Z#0-9_]\+\|[a-zA-Z#0-9_]\+\)'
 499 |     let v_ptn = '\(^\s*let\s\+\)\@<=\([a-zA-Z0-9:_]\+\)'
 500 |     let c_ptn = '\(^\s*com[mand]\*!\?\s\+\)\@<=[a-zA-Z]*'
 501 |     let v_comps = [ ]
 502 |     let f_comps = [ ]
 503 |     let c_comps = [ ]
 504 |     for line in lines
 505 |       if line =~ f_ptn
 506 |         cal add(f_comps,matchstr(line,f_ptn ))
 507 |       elseif line =~ v_ptn
 508 |         cal add(v_comps,matchstr(line,v_ptn))
 509 |       elseif line =~ c_ptn 
 510 |         cal add(c_comps,matchstr(line,c_ptn))
 511 |       endif
 512 |     endfor
 513 | 
 514 |     if len(b:tokens) > 0
 515 | 
 516 |       if s:debug
 517 |         echo b:tokens
 518 |         sleep 1
 519 |         echo b:context
 520 |         sleep 1
 521 |       endif
 522 | 
 523 |       let first = b:tokens[0]
 524 |       let t = remove(b:tokens,-1)
 525 | 
 526 |       if s:debug
 527 |         echo first
 528 |         sleep 1
 529 |         echo t
 530 |         sleep 1
 531 |       endif
 532 | 
 533 |       if t =~ 'call\?'
 534 |         " cal extend(comps,s:builtin_function_list)
 535 |         call s:CompleteBuiltinFunctions()
 536 |         cal extend(comps,f_comps)
 537 |         cal extend(comps,s:RuntimeFunList())
 538 |       elseif first =~ '[nvic]\?map$'
 539 |         cal extend(comps,s:mapargments)
 540 |         if t == ':'
 541 |           let coms = [ ]
 542 |           cal extend(coms,s:builtin_command_list)
 543 |           cal extend(coms,s:RuntimeComList())
 544 |           cal map(coms,'":".v:val')
 545 |           cal extend(comps,coms)
 546 |         endif
 547 |       " command completion
 548 |       elseif first =~ 'com\%[mand]!\?' && t =~ '-complete=custom\(list\)\?,$'
 549 |         " cal extend(comps,s:builtin_function_list)
 550 |         call s:CompleteBuiltinFunctions()
 551 |         cal extend(comps,f_comps)
 552 |         cal extend(comps,s:RuntimeFunList())
 553 |         " little patch for command completion function name
 554 |         cal map(comps,'substitute(v:val,"($","","")')
 555 |       elseif first =~ 'com\%[mand]!\?'
 556 |         cal extend(comps,s:command_attr)
 557 |         cal extend(comps,s:command_complete)
 558 |       elseif t =~ 'au\%[tocmd]!\?'
 559 |         cal extend(comps,s:autocmd_events)
 560 |       elseif t =~ '^has(["'']'
 561 |         cal extend(comps,s:features)
 562 |       elseif t =~ '^has($'
 563 |         cal extend(comps, map(copy(s:features),'''"'' . v:val . ''")'''))
 564 |       " expr context
 565 |       elseif t =~ '[=+-/*]' || t =~ '\w\+($' || t =~ '^\(if\|else\|elseif\|while\|for\|in\)'
 566 |         cal extend(comps,v_comps)
 567 |         cal extend(comps,s:RuntimeVarList())
 568 |         "cal extend(comps,s:builtin_function_list)
 569 |         call s:CompleteBuiltinFunctions()
 570 |         cal extend(comps,f_comps)
 571 |         cal extend(comps,s:RuntimeFunList())
 572 |       " option context
 573 |       elseif t =~ 'set\%[local]'
 574 |         cal extend(comps,s:builtin_option_list)
 575 |       " variable declare context
 576 |       elseif t =~ 'let'
 577 |         cal extend(comps,v_comps)
 578 |         cal extend(comps,s:RuntimeVarList())
 579 |       else
 580 |         cal extend(comps,f_comps)
 581 |         "cal extend(comps,s:builtin_function_list)
 582 |         call s:CompleteBuiltinFunctions()
 583 |         cal extend(comps,s:RuntimeFunList())
 584 | 
 585 |         cal extend(comps,s:builtin_command_list)
 586 |         cal extend(comps,s:RuntimeComList())
 587 |       endif
 588 |     else
 589 |       cal extend(comps,s:builtin_command_list)
 590 |       cal extend(comps,c_comps)
 591 |       cal extend(comps,s:RuntimeComList())
 592 |     endif
 593 | 
 594 |     let v_val_filter = "v:val =~ ".string('^\%(.*#\)\?'.a:base).' '.( s:additional_regex == "" ? "" : '|| v:val =~ '.string('^\%(.*#\)\?'.s:additional_regex)  )
 595 |     cal filter(comps, v_val_filter )
 596 |     cal sort(comps)
 597 | 
 598 |     for c in comps
 599 |       call complete_add(c)
 600 |     endfor
 601 | 
 602 |     if b:prefix_completion == ""
 603 | 
 604 |       " scanning Vim files the first time will take time..
 605 |       " take functions from autoload directories
 606 |       let autoload_functions = vim_dev_plugin#ListOfAutoloadFiles()
 607 |       for file in values(autoload_functions)
 608 |         if complete_check() | return [] | endif
 609 |         if expand(file) == expand('%:p')
 610 |           let file_content = b:scanned_buf
 611 |         else
 612 |           let file_content = cached_file_contents#CachedFileContents(file,
 613 |                 \ s:c['vim_scan_func'], 0)
 614 |         endif
 615 |         let functions = copy(file_content['declared autoload functions'])
 616 |         cal filter(functions, substitute(v_val_filter,'v:val','v:key','g') )
 617 |         for [k,v] in items(functions)
 618 |           call complete_add({'word': k.'(', 'menu': v.args, 'info': v.args})
 619 |           unlet k v
 620 |         endfor
 621 |       endfor
 622 |     endif
 623 | 
 624 |   endif
 625 | endf "}}}
 626 | fun! s:RuntimeComList() "{{{
 627 |   let c = GetCache('vim_runtime_cmd')
 628 |   if type(c) == 3
 629 |     return c
 630 |   endif
 631 | 
 632 |   redir => out
 633 |   silent! com
 634 |   redir END
 635 |   let list = split(out,"\n")
 636 |   cal remove( list , 0 )   " remove title
 637 |   cal map(list,'matchstr(v:val,''\(^!\?\s*\)\@<=[a-zA-Z0-9]\+'')')
 638 | 
 639 |   cal SetCache('vim_runtime_cmd',list)
 640 |   return list
 641 | endf "}}}
 642 | fun! s:RuntimeVarList() "{{{
 643 |   let c = GetCache('vim_runtime_var' . b:g_prefix)
 644 |   if type(c) == 3
 645 |     return c
 646 |   endif
 647 | 
 648 |   redir => varlist
 649 |   silent! let
 650 |   redir END
 651 |   let list = split(varlist,"\n")
 652 |   cal map(list,'matchstr(v:val,''^[a-zA-Z0-9:_#.]\+'')')
 653 |   if b:g_prefix 
 654 |     cal map(list,'substitute(v:val,''^\([A-Z]\)'',''g:\1'',"")')
 655 |   endif
 656 |   cal SetCache('vim_runtime_var' . b:g_prefix ,list)
 657 |   return list
 658 | endf "}}}
 659 | 
 660 | fun! s:RuntimeFunList() "{{{
 661 |   " this func completes global functions only
 662 |   " see continue below
 663 | 
 664 |   let c = GetCache('vim_runtime_fun' . b:g_prefix)
 665 |   if type(c) != type({})
 666 |     " build cache
 667 | 
 668 |     redir => flist
 669 |     silent! fun
 670 |     redir END
 671 |     unlet c
 672 |     let c = {}
 673 |     for l in split(flist,"\n")
 674 |       if l =~ '#\|SNR'
 675 |         " - s: functions are skipped because we only want s: functions of the
 676 |         "   current file to appear
 677 |         " - autoload functions (containing #) are skipped cause they are
 678 |         "   completed by scan func result
 679 |         continue
 680 |       endif
 681 |       " get name and args:
 682 |       let li = matchlist(l,'\([A-Za-z_]\+\)(\([^)]*\)')
 683 |       if len(li) > 0 && li[1] != ""
 684 |         let c[li[1]] = li[2]
 685 |       endif
 686 |     endfor
 687 |     cal SetCache('vim_runtime_fun' . b:g_prefix,c)
 688 |   endif
 689 | 
 690 |   for [k,v] in items(c)
 691 |     if s:Matches(k)
 692 |       call complete_add({'word': k.'(', 'menu': v, 'info': v})
 693 |     endif
 694 |     unlet k v
 695 |   endfor
 696 | 
 697 |   " old interface is no longer used here:
 698 |   return []
 699 | endf "}}}
 700 | fun! s:AutoloadPrefixes(funcs) "{{{
 701 |   let funcs = filter(copy(a:funcs),'v:val =~ ''\w\+#''')
 702 |   let heads = { }
 703 |   for f in funcs 
 704 |     let parts = split(f,'#')
 705 |     while len(parts) > 0
 706 |       cal remove(parts,-1)
 707 |       if len(parts) > 0
 708 |         let heads[ join(parts,"#") . '#' ] = 1
 709 |       endif
 710 |     endwhile
 711 |   endfor
 712 |   return keys(heads)
 713 | endf "}}}
 714 | 
 715 | fun! s:CompleteBuiltinFunctions()
 716 |   let func_lines = []
 717 |   let lines = readfile($VIMRUNTIME.'/doc/eval.txt')
 718 |   for idx in range(0, len(lines)-1)
 719 |     if lines[idx][:11] == "abs( {expr})"
 720 |       let start = idx
 721 |       " at abs\t  all function names are repeated a second time, this time
 722 |       " with a long description. stop here
 723 |     elseif lines[idx][:11] == "abs({expr})\t"
 724 |       let stop = idx
 725 |       break
 726 |     endif
 727 |   endfor
 728 | 
 729 |   let func = ""
 730 |   for idx in range(stop,start,-1)
 731 |     let func = substitute(lines[idx],'[ \t]\+',' ','g')." ".func
 732 |     let matches = matchlist(func, '^\([^( \t]\+\)(\([^)]*\))\(.*\)')
 733 |     if len(matches) > 0 && s:Matches(matches[1])
 734 |       cal complete_add({'word': matches[1].'(', 'menu': '('.matches[2].') ' .matches[3]})
 735 |       let func = ""
 736 |     endif
 737 |   endfor
 738 | endfun
 739 | 
 740 | " scan func - simple .vim file parser It can collect used and defined autoload functions "{{{1
 741 | 
 742 | let s:vl_regex = {}
 743 | let s:vl_regex['fap']='\%(\w\+#\)\+' " match function autoload prefix ( blah#foo#)
 744 | let s:vl_regex['ofp']='\%(\w\+#\)*' " optional match function location prefix ( blah#foo#)
 745 | let s:vl_regex['fp']='\%('.s:vl_regex['ofp'].'\|s:\|g:\)' " match any (or no function prefix)
 746 | let s:vl_regex['Fn']='\w*'  " match function name
 747 | let s:vl_regex['uFn']='\u\w*'  " match user function name
 748 | let s:vl_regex['function']='^\s*fun\%(ction\)\=!\=\s\+'
 749 | " match function declaration and get function name / doesn't match fun s:Name
 750 | let s:vl_regex['fn_decl']=s:vl_regex['function'].'\zs'.s:vl_regex['fp'].s:vl_regex['uFn'].'\ze('
 751 | 
 752 | fun! vim_dev_plugin#ScanFunc(filename)
 753 |   return vim_dev_plugin#ScanFuncLines(readfile(a:filename), a:filename)
 754 | endf
 755 | 
 756 | " scan a vim file returning list of defined functions
 757 | fun! vim_dev_plugin#ScanFuncLines(lines, filename)
 758 |   let lines = a:lines
 759 | 
 760 |   let declared_functions = vim_dev_plugin#GetAllDeclaredFunctions(
 761 | 				      \ lines)
 762 |   let declared_autoload_functions = filter(deepcopy(declared_functions),
 763 | 	      \ 'v:key =~ '.string(s:vl_regex['fap'].s:vl_regex['uFn']))
 764 |   let used_user_functions = vim_dev_plugin#GetAllUsedUserFunctions(
 765 | 				      \ lines)
 766 |   let used_autoload_functions = filter(deepcopy(used_user_functions),
 767 | 	      \ 'v:key =~ '.string(s:vl_regex['fap'].s:vl_regex['uFn']))
 768 |   let g:c = s:vl_regex['fap'].s:vl_regex['uFn']
 769 | 
 770 |   let vars_g = []
 771 |   let vars_b = []
 772 |   let vars_s = []
 773 | 
 774 |   let n = 1
 775 |   let in_fun = 0
 776 |   for l in lines
 777 |     if l =~ '^\s*fun'
 778 |       let in_fun = 1
 779 |     elseif l =~ '^\s*endf\s*$' || '^\sendfu'
 780 |       let in_fun = 0
 781 |     endif
 782 |     for i in split(l,'let\s\+\ze\%([sgb]:\)',1)[1:]
 783 |       let p = ''
 784 |       if len(i) > 2 && i[1] == ':'
 785 |         let p = i[0]
 786 |         let i=i[2:]
 787 |       endif
 788 |       let n = matchstr(i,'\zs[^=[\]()\n \t]*')
 789 | 
 790 |       if p == "" && !in_fun
 791 |         call add(vars_g, { 'word': n, 'menu': 'g: '.i[len(n):70], 'line': n })
 792 |       elseif p != ""
 793 |         call add(vars_{p}, { 'word': n, 'menu': p.': '.i[len(n):70], 'line': n })
 794 |       endif
 795 | 
 796 |     endfor
 797 |     let n = n+1
 798 |   endfor
 799 | 
 800 |   if type(declared_autoload_functions) != type({})
 801 |     throw filename
 802 |   endif
 803 | 
 804 |   return { 'declared functions' : declared_functions
 805 |        \ , 'declared autoload functions' : declared_autoload_functions
 806 |        \ , 'used autoload functions' : used_autoload_functions
 807 |        \ , 'used user functions' : used_user_functions
 808 |       \ , 'vars_g' : vars_g
 809 |       \ , 'vars_b' : vars_b
 810 |       \ , 'vars_s' : vars_s
 811 |        \ }
 812 | endf
 813 | 
 814 | 
 815 | 
 816 | " complete a: (arg names)
 817 | fun! vim_dev_plugin#CompleteFunLocalLets()
 818 |   let lidx = line('.')
 819 |   let r = []
 820 |   while lidx > 0
 821 |     let l = getline(lidx)
 822 |     if l =~ '^\s*fun'
 823 |       for x in r | call complete_add(x) | endfor
 824 |       return
 825 |     endif
 826 |     if l =~ '^\s*endf\s*$' || '^\sendfu'
 827 |       " not in func
 828 |       return
 829 |     endif
 830 |     for name in split(l,'\%(let\|for\)\s\+\ze\S')[1:]
 831 |       if len(name) > 2 && name[1] == ':' | continue | endif
 832 |       let n = matchstr(name,'\zs[^=[\]()\n \t]*')
 833 |       call add(r, {'word': n, 'menu': 'local let in func'})
 834 |     endfor
 835 |     let lidx = lidx -1
 836 |   endwhile
 837 | endf
 838 | 
 839 | 
 840 | " v:completion
 841 | fun! vim_dev_plugin#VCompletion()
 842 |   sp
 843 |   h eval.txt
 844 |   let items = map(filter(getline(0, '$'),'v:val =~ "^v:"'),'matchstr(v:val, "v:\\zs[^ \t]*\\ze")')
 845 |   bw!
 846 |   for i in items
 847 |     if !s:Matches(i) | continue | endif
 848 |     " a:0 a:1 etc are not worth adding. They are too short
 849 |     call complete_add({
 850 |           \ 'word': i
 851 |           \ })
 852 |   endfor
 853 | endf
 854 | 
 855 | " complete a: (arg names)
 856 | fun! vim_dev_plugin#ACompletion()
 857 |   let line = search('^\s*\%(fun\|endf\)', 'bn')
 858 |   if line > 0
 859 |     let l = getline(line)
 860 |     let nr = 1
 861 |     for arg in split(matchstr(getline(line), '(\zs[^)]*'),'\s*,\s*')
 862 |       if arg == '...'
 863 |         if !s:Matches('000') | continue | endif
 864 |         " a:0 a:1 etc are not worth adding. They are too short
 865 |         call complete_add({
 866 |               \ 'word': '000',
 867 |               \ 'menu': ' func arg nr: '.nr
 868 |               \ })
 869 |       else
 870 |         if !s:Matches('a:'.arg) | continue | endif
 871 |         call complete_add({
 872 |               \'word': arg,
 873 |               \'menu': ' func arg nr: '.nr
 874 |               \})
 875 |       endif
 876 |       let nr = nr +1
 877 |     endfor
 878 |   endif
 879 | endf
 880 | 
 881 | " complete s: (buffer scope names and functions)
 882 | fun! vim_dev_plugin#SCompletion()
 883 |   " let s: bindings
 884 |   for i in b:scanned_buf['vars_s']
 885 |     if !s:Matches(i.word) | continue | endif
 886 |     call complete_add(i)
 887 |   endfor
 888 |   " fun s:.. functions
 889 |   let scanned = b:scanned_buf
 890 |   for [n,value] in items(scanned['declared functions'])
 891 |     let line = value.line
 892 |     if n =~ '^s:'
 893 |       if !s:Matches(n) | continue | endif
 894 |       let info = ( has_key(value,'args') ? value.args : '').' func this buf line '. line
 895 |       call complete_add({
 896 |             \'word': n[2:].'(',
 897 |             \'menu': info,
 898 |             \'info': info 
 899 |             \})
 900 |       unlet n value line
 901 |     endif
 902 |   endfor
 903 | endf
 904 | 
 905 | " complete s: (buffer scope names and functions)
 906 | " yes, this only finds b: definitions in the current buffer (FIXME)
 907 | " Ideally parse all ftpluginfiles etc
 908 | fun! vim_dev_plugin#BCompletion()
 909 |   " let s: bindings
 910 |   for i in b:scanned_buf['vars_b']
 911 |     if !s:Matches(i.word) | continue | endif
 912 |     call complete_add(i)
 913 |   endfor
 914 | endf
 915 | 
 916 | fun! vim_dev_plugin#GCompletion()
 917 |   " let s: bindings
 918 |   for i in b:scanned_buf['vars_g']
 919 |     if !s:Matches(i.word) | continue | endif
 920 |     call complete_add(i)
 921 |   endfor
 922 | endf
 923 | 
 924 | 
 925 | " returns dictionary { "<functionname>" : <line_nr> , ... }
 926 | function! vim_dev_plugin#GetAllDeclaredFunctions(file_as_string_list)
 927 |   let functions = {}
 928 |   let line_nr = 1
 929 |   for l in a:file_as_string_list
 930 |     let function = matchstr(l,s:vl_regex['fn_decl'])
 931 |       if function !=  ""
 932 | 	let functions[function] = { 'line': line_nr, 'args': matchstr(l, '(\zs[^)]*') }
 933 |       endif
 934 |     let line_nr = line_nr + 1
 935 |   endfor
 936 |   return functions
 937 | endfunction
 938 | 
 939 | " returns a dictionary { "function name": linenr, ...}
 940 | " thus the last occurence will be listed
 941 | function! vim_dev_plugin#GetAllUsedUserFunctions(file_as_string_list)
 942 |   let file = a:file_as_string_list
 943 |   let result = {}
 944 |   let line_nr=1
 945 |   for l in file
 946 |     if l =~ '^\s*"' || l =~ s:vl_regex['fn_decl']
 947 |       let line_nr = line_nr + 1
 948 |       continue " simple comment handling.. can be improved much
 949 | 	       " also continue on function declarations
 950 |     endif
 951 |     let matches = map(split(l,s:vl_regex['fp'].s:vl_regex['uFn'].'(\zs\ze'),"matchstr(v:val,'".s:vl_regex['fp'].s:vl_regex['uFn']."(')")
 952 |     for m in map(matches,"substitute(v:val,'($','','')")
 953 |       if m == ""
 954 | 	continue
 955 |       endif
 956 |       if !exists("result['".m."']")
 957 | 	let result[m] = line_nr
 958 |       endif
 959 |     endfor
 960 |     let line_nr = line_nr+1
 961 |   endfor
 962 |   return result
 963 | endfunction
 964 | 
 965 | " path/autoload/foo/bar.vim -> foo#bar
 966 | fun! vim_dev_plugin#GetPrefix(path)
 967 |   return substitute(matchstr(a:path,'.*autoload[/\\]\zs.*\ze\.vim$'),'[/\\]','#','g')
 968 | endf
 969 | 
 970 | fun! vim_dev_plugin#GlobRuntimePath(list_rel)
 971 |   let files = []
 972 |   for path in reverse(split(&runtimepath,','))
 973 |     for p in a:list_rel
 974 |       call extend(files, split(glob(expand(path).'/'.p),"\n"))
 975 |     endfor
 976 |   endfor
 977 |   return files
 978 | endf
 979 | 
 980 | function! vim_dev_plugin#ListOfNonAutoLoadVimFiles()
 981 |   " ftdetect etc is not that important. (TODO)?
 982 |   return  
 983 |         \ filter([expand('%'), expand("~/.vimrc"), expand("~/_vimrc")], 'filereadable(v:val)')
 984 |         \ + vim_dev_plugin#GlobRuntimePath(['plugin/**/*.vim','syntax/**/*.vim','after/**.*.vim'])
 985 | endf
 986 | 
 987 | " returns list of all used autoload files
 988 | " If you have 2 autoload/file.vim files
 989 | " the one beeing first in runtimepath will be used
 990 | " returns dictionary { "prefix": "file", ... }
 991 | " file autoload/blah/ehh.vim results in prefix
 992 | " blah#
 993 | function! vim_dev_plugin#ListOfAutoloadFiles()
 994 |   let files = {}
 995 |   for f in vim_dev_plugin#GlobRuntimePath(['autoload/**/*.vim'])
 996 |     let files[vim_dev_plugin#GetPrefix(f)] = f
 997 |   endfor
 998 |   return files
 999 | endfunction
1000 | 
1001 | fun! s:SplitCurrentLineAtCursor()
1002 |   let pos = col('.') -1
1003 |   let line = getline('.')
1004 |   return [strpart(line,0,pos), strpart(line, pos, len(line)-pos)]
1005 | endfunction
1006 | 
1007 | "|func only works with autoload functions 
1008 | "|     is intended to be used with vim-addon-goto-thing-at-cursor to jump to files.
1009 | "|     limitation: only finds first match (because FileInDirOfRuntimePath does so)
1010 | "|     returns either [[filename, linenr]]
1011 | "|     or [filename]. in case that function does not exist
1012 | "|     (than you can jump to the file and add it manually)
1013 | function! vim_dev_plugin#GetFuncLocation(...)
1014 |   let addNonExisting = 1
1015 |   if &filetype != 'vim' | return  [] | endif
1016 |   let [b,a] = s:SplitCurrentLineAtCursor()
1017 |   let func = matchstr(b,'\zs\%(s:\)\?[#_a-zA-Z0-9]*\ze$').matchstr(a,'^\zs[_#a-zA-Z0-9]*\ze')
1018 |   let results = vim_dev_plugin#FindFunction(func)
1019 |   if addNonExisting
1020 |     call extend(results, 
1021 |       \ map(split(&runtimepath,','),
1022 |            \ 'v:val.'.string("/autload/".substitute(func,'#','/','g'))))
1023 |   endif
1024 |   return results
1025 | endfunction
1026 | 
1027 | fun! vim_dev_plugin#FindFunction(func) abort
1028 |   let results = []
1029 | 
1030 |   if a:func =~ '#'
1031 |     " autoload function
1032 |     let autofile_list = vim_dev_plugin#ListOfAutoloadFiles()
1033 |     let keys = keys(autofile_list)
1034 |     let reg_prefix = '^'.substitute(a:func, '\(.*\)#[^#]*','\1','')
1035 |     for [k, file] in items(autofile_list)
1036 |       if k !~ reg_prefix
1037 |         " path does not match func prefix
1038 |         continue
1039 |       endif
1040 |       let file_info = cached_file_contents#CachedFileContents(file,
1041 |               \ s:c['vim_scan_func'], 0)
1042 |       let functions ={}
1043 |       call extend(functions, file_info['declared autoload functions'])
1044 |       call extend(functions, file_info['declared functions'])
1045 |       if has_key(functions, a:func)
1046 |         let line = functions[a:func]['line']
1047 |           call add(results, {'filename': file, 'line_nr': line})
1048 |       endif
1049 |       unlet k
1050 |       unlet file
1051 |     endfor
1052 | 
1053 |     " if file does not exist propose editing it:
1054 |     if len(results) == 0
1055 |       let file = substitute(a:func,'#[^#]*$','','') 
1056 |       if has_key(autofile_list, file)
1057 |         return [autofile_list[file]]
1058 |       endif
1059 |     endif
1060 |   else
1061 |     " copy paste of if .. :(
1062 |     if a:func =~ '^s:'
1063 |       " file local function
1064 |       " TODO write should not be necessary
1065 |       let files = [expand('%')]
1066 |     else
1067 |       let files = 
1068 |             \ vim_dev_plugin#ListOfNonAutoLoadVimFiles()
1069 |             \ + values(vim_dev_plugin#ListOfAutoloadFiles())
1070 |     endif
1071 | 
1072 |     for file in files
1073 |       let file_info = cached_file_contents#CachedFileContents(file,
1074 |               \ s:c['vim_scan_func'], 0)
1075 |       let functions ={}
1076 |       call extend(functions, file_info['declared functions'])
1077 |       if has_key(functions, a:func)
1078 |         let line = functions[a:func]['line']
1079 |           call add(results, {'filename': file, 'line_nr': line})
1080 |       endif
1081 |     endfor
1082 |   endif
1083 |   return results
1084 | endf
1085 | 
1086 | 
1087 | " jumps to this kind of error location:
1088 | " Error detected while processing function vim_dev_plugin#FindFunction:
1089 | " line   24: 
1090 | " see :messages
1091 | 
1092 | " TODO even put trace in quickfix ?
1093 | fun! vim_dev_plugin#VimLGotoLastError()
1094 | 
1095 |   let lines = tlib#cmd#OutputAsList('messages')
1096 | 
1097 |   " get line number from previous line which looks like 'line: 17'
1098 |   let get_line = 'let line_offset = matchstr(lines[l+1], '.string('^line\s*\zs\d\+\ze:$').')'
1099 | 
1100 |   " put error in the line below assuming the error message was in line +2
1101 |   let put_error = "exec 'normal o ERROR was:!'.lines[l+2].' ( remove this line by u(ndo) )'"
1102 | 
1103 |   let match_trace = '^Error detected while processing function \zs.*\ze:$'
1104 |   let match_processing_error = '^Error detected while processing \zs.*\ze:'
1105 | 
1106 |   for l in range(len(lines)-1, 0, -1)
1107 |     let trace = matchstr(lines[l], match_trace)
1108 |     if trace != ""
1109 |       let locations = split(trace,'\.\.')
1110 |       exec get_line
1111 |       let fun_locations = vim_dev_plugin#FindFunction(locations[-1])
1112 |       if len(fun_locations) == 0
1113 |         echo "no locations found for error line ".lines[l]
1114 |         break
1115 |       endif
1116 |       let location = eval(tlib#input#List("s","multiple locations found", map(fun_locations, 'string(v:val)') ))
1117 |       exec 'e '.fnameescape(location.filename)
1118 |       exec (location.line_nr+line_offset)
1119 |       " is this a good idea? use u to unde this change
1120 |       exec put_error
1121 |       break
1122 |     endif
1123 | 
1124 |     let file = matchstr(lines[l], match_processing_error)
1125 |     if file != ""
1126 |       exec get_line
1127 |       exec 'e '.fnameescape(file)
1128 |       exec line_offset
1129 |       exec put_error
1130 |       break
1131 |     endif
1132 |   endfor
1133 | endf
1134 | 
1135 | " get option list from documentation. Is used for &completion
1136 | " TODO take 't_AB' etc into account
1137 | " Is there another way to get a list of all options?
1138 | fun! vim_dev_plugin#OptionList()
1139 |   if !exists('s:option_list')
1140 |     let func_lines = []
1141 |     let lines = readfile($VIMRUNTIME.'/doc/options.txt')
1142 |     let options = []
1143 |     let idx = 0
1144 |     let r = "^'\\([^' ]*\\)'\\s*'\\([^' ]*\\)'\\s*\\(.*\\)"
1145 |     while idx < len(lines)
1146 |       let l = lines[idx]
1147 |       if l =~ r
1148 |         " option found
1149 |         let m = matchlist(l, r)
1150 |         let idx += 1
1151 |         let description = m[3]
1152 |         while lines[idx] =~ '^\t\{1,3}[^\t]*'
1153 |           let description .=  "\n".lines[idx][1:]
1154 |           let idx += 1
1155 |         endwhile
1156 |         call add(options, {'long': m[1], 'short': m[2], 'description': description})
1157 |       else
1158 |         let idx +=1
1159 |       endif
1160 |     endwhile
1161 | 
1162 |     let names = map(copy(options), 'v:val.long')
1163 | 
1164 |     let s:option_list = options
1165 |   endif
1166 | 
1167 |   return s:option_list
1168 | endf
1169 | 
1170 | fun! vim_dev_plugin#EvalVimScriptRegion(s,e)
1171 |   let lines = getline(a:s,a:e)
1172 |   let file = tempname()
1173 |   cal writefile(lines,file)
1174 |   redir @e
1175 |   silent exec ':source '.file
1176 |   cal delete(file)
1177 |   redraw
1178 |   redir END
1179 |   echo "Region evaluated."
1180 | 
1181 |   if strlen(getreg('e')) > 0
1182 |     10new
1183 |     redraw
1184 |     silent file "EvalResult"
1185 |     setlocal noswapfile  buftype=nofile bufhidden=wipe
1186 |     setlocal nobuflisted nowrap cursorline nonumber fdc=0
1187 |     " syntax init
1188 |     set filetype="eval"
1189 |     syn match ErrorLine +^E\d\+:.*$+
1190 |     hi link ErrorLine Error
1191 |     silent $put =@e
1192 |   endif
1193 | endf
1194 | 
1195 | " vim:fdm=marker
1196 | 


--------------------------------------------------------------------------------
/doc/vim-dev-plugin.txt:
--------------------------------------------------------------------------------
1 | related work: statically check function arguments:
2 | http://vimargumentchec.hg.sourceforge.net:8000/hgroot/vimargumentchec/vimargumentchec
3 | 


--------------------------------------------------------------------------------
/ftplugin/vim.vim:
--------------------------------------------------------------------------------
 1 | " exec vam#DefineAndBind('s:c','vim_dev','{}')
 2 | if !exists('vim_dev') | let vim_dev = {} | endif | let s:c = vim_dev
 3 | 
 4 | call on_thing_handler#AddOnThingHandler('b', funcref#Function('vim_dev_plugin#GetFuncLocation'))
 5 | 
 6 | " smart VimL completion also supporting CamelCase like matching unless you change the default
 7 | 
 8 | call vim_addon_completion#InoremapCompletions(s:c, [
 9 |    \ { 'setting_keys' : ['complete_lhs'], 'fun': 'vim_dev_plugin#VimOmniComplete'},
10 |    \ ] )
11 | 


--------------------------------------------------------------------------------
/ftplugin/vim/eval.vim:
--------------------------------------------------------------------------------
1 | command! -buffer -range Eval  :cal vim_dev_plugin#EvalVimScriptRegion(<line1>,<line2>)
2 | vnoremap <buffer> <silent> <cr>   :Eval<CR>
3 | 


--------------------------------------------------------------------------------
/plugin/vim_dev_plugin.vim:
--------------------------------------------------------------------------------
1 | " exec vam#DefineAndBind('s:c','vim_dev','{}')
2 | if !exists('vim_dev') | let vim_dev = {} | endif | let s:c = vim_dev
3 | let s:c.complete_lhs = get(s:c, 'complete_lhs', '<c-x>v')
4 | 
5 | command! -nargs=0 VimLGotoLastError call vim_dev_plugin#VimLGotoLastError()
6 | 


--------------------------------------------------------------------------------
/spell/en.utf-8.add:
--------------------------------------------------------------------------------
1 | Shougo
2 | Modeline
3 | vim
4 | gui
5 | 


--------------------------------------------------------------------------------