diff --git a/vim-plugins/bundle/AutoComplPop/doc/tags b/vim-plugins/bundle/AutoComplPop/doc/tags new file mode 100644 index 0000000..4519664 --- /dev/null +++ b/vim-plugins/bundle/AutoComplPop/doc/tags @@ -0,0 +1,45 @@ +:AcpDisable acp.txt /*:AcpDisable* +:AcpEnable acp.txt /*:AcpEnable* +:AcpLock acp.txt /*:AcpLock* +:AcpUnlock acp.txt /*:AcpUnlock* +acp acp.txt /*acp* +acp-about acp.txt /*acp-about* +acp-author acp.txt /*acp-author* +acp-changelog acp.txt /*acp-changelog* +acp-commands acp.txt /*acp-commands* +acp-contact acp.txt /*acp-contact* +acp-installation acp.txt /*acp-installation* +acp-introduction acp.txt /*acp-introduction* +acp-options acp.txt /*acp-options* +acp-perl-omni acp.txt /*acp-perl-omni* +acp-snipMate acp.txt /*acp-snipMate* +acp-thanks acp.txt /*acp-thanks* +acp-usage acp.txt /*acp-usage* +acp.txt acp.txt /*acp.txt* +autocomplpop acp.txt /*autocomplpop* +g:acp_behavior acp.txt /*g:acp_behavior* +g:acp_behavior-command acp.txt /*g:acp_behavior-command* +g:acp_behavior-completefunc acp.txt /*g:acp_behavior-completefunc* +g:acp_behavior-meets acp.txt /*g:acp_behavior-meets* +g:acp_behavior-onPopupClose acp.txt /*g:acp_behavior-onPopupClose* +g:acp_behavior-repeat acp.txt /*g:acp_behavior-repeat* +g:acp_behaviorCssOmniPropertyLength acp.txt /*g:acp_behaviorCssOmniPropertyLength* +g:acp_behaviorCssOmniValueLength acp.txt /*g:acp_behaviorCssOmniValueLength* +g:acp_behaviorFileLength acp.txt /*g:acp_behaviorFileLength* +g:acp_behaviorHtmlOmniLength acp.txt /*g:acp_behaviorHtmlOmniLength* +g:acp_behaviorKeywordCommand acp.txt /*g:acp_behaviorKeywordCommand* +g:acp_behaviorKeywordIgnores acp.txt /*g:acp_behaviorKeywordIgnores* +g:acp_behaviorKeywordLength acp.txt /*g:acp_behaviorKeywordLength* +g:acp_behaviorPerlOmniLength acp.txt /*g:acp_behaviorPerlOmniLength* +g:acp_behaviorPythonOmniLength acp.txt /*g:acp_behaviorPythonOmniLength* +g:acp_behaviorRubyOmniMethodLength acp.txt /*g:acp_behaviorRubyOmniMethodLength* +g:acp_behaviorRubyOmniSymbolLength acp.txt /*g:acp_behaviorRubyOmniSymbolLength* +g:acp_behaviorSnipmateLength acp.txt /*g:acp_behaviorSnipmateLength* +g:acp_behaviorUserDefinedFunction acp.txt /*g:acp_behaviorUserDefinedFunction* +g:acp_behaviorUserDefinedMeets acp.txt /*g:acp_behaviorUserDefinedMeets* +g:acp_behaviorXmlOmniLength acp.txt /*g:acp_behaviorXmlOmniLength* +g:acp_completeOption acp.txt /*g:acp_completeOption* +g:acp_completeoptPreview acp.txt /*g:acp_completeoptPreview* +g:acp_enableAtStartup acp.txt /*g:acp_enableAtStartup* +g:acp_ignorecaseOption acp.txt /*g:acp_ignorecaseOption* +g:acp_mappingDriven acp.txt /*g:acp_mappingDriven* diff --git a/vim-plugins/bundle/AutoComplPop/doc/tags-ja b/vim-plugins/bundle/AutoComplPop/doc/tags-ja new file mode 100644 index 0000000..816c6e0 --- /dev/null +++ b/vim-plugins/bundle/AutoComplPop/doc/tags-ja @@ -0,0 +1,44 @@ +!_TAG_FILE_ENCODING utf-8 // +:AcpDisable acp.jax /*:AcpDisable* +:AcpEnable acp.jax /*:AcpEnable* +:AcpLock acp.jax /*:AcpLock* +:AcpUnlock acp.jax /*:AcpUnlock* +acp acp.jax /*acp* +acp-about acp.jax /*acp-about* +acp-author acp.jax /*acp-author* +acp-commands acp.jax /*acp-commands* +acp-contact acp.jax /*acp-contact* +acp-installation acp.jax /*acp-installation* +acp-introduction acp.jax /*acp-introduction* +acp-options acp.jax /*acp-options* +acp-perl-omni acp.jax /*acp-perl-omni* +acp-snipMate acp.jax /*acp-snipMate* +acp-usage acp.jax /*acp-usage* +acp.txt acp.jax /*acp.txt* +autocomplpop acp.jax /*autocomplpop* +g:acp_behavior acp.jax /*g:acp_behavior* +g:acp_behavior-command acp.jax /*g:acp_behavior-command* +g:acp_behavior-completefunc acp.jax /*g:acp_behavior-completefunc* +g:acp_behavior-meets acp.jax /*g:acp_behavior-meets* +g:acp_behavior-onPopupClose acp.jax /*g:acp_behavior-onPopupClose* +g:acp_behavior-repeat acp.jax /*g:acp_behavior-repeat* +g:acp_behaviorCssOmniPropertyLength acp.jax /*g:acp_behaviorCssOmniPropertyLength* +g:acp_behaviorCssOmniValueLength acp.jax /*g:acp_behaviorCssOmniValueLength* +g:acp_behaviorFileLength acp.jax /*g:acp_behaviorFileLength* +g:acp_behaviorHtmlOmniLength acp.jax /*g:acp_behaviorHtmlOmniLength* +g:acp_behaviorKeywordCommand acp.jax /*g:acp_behaviorKeywordCommand* +g:acp_behaviorKeywordIgnores acp.jax /*g:acp_behaviorKeywordIgnores* +g:acp_behaviorKeywordLength acp.jax /*g:acp_behaviorKeywordLength* +g:acp_behaviorPerlOmniLength acp.jax /*g:acp_behaviorPerlOmniLength* +g:acp_behaviorPythonOmniLength acp.jax /*g:acp_behaviorPythonOmniLength* +g:acp_behaviorRubyOmniMethodLength acp.jax /*g:acp_behaviorRubyOmniMethodLength* +g:acp_behaviorRubyOmniSymbolLength acp.jax /*g:acp_behaviorRubyOmniSymbolLength* +g:acp_behaviorSnipmateLength acp.jax /*g:acp_behaviorSnipmateLength* +g:acp_behaviorUserDefinedFunction acp.jax /*g:acp_behaviorUserDefinedFunction* +g:acp_behaviorUserDefinedMeets acp.jax /*g:acp_behaviorUserDefinedMeets* +g:acp_behaviorXmlOmniLength acp.jax /*g:acp_behaviorXmlOmniLength* +g:acp_completeOption acp.jax /*g:acp_completeOption* +g:acp_completeoptPreview acp.jax /*g:acp_completeoptPreview* +g:acp_enableAtStartup acp.jax /*g:acp_enableAtStartup* +g:acp_ignorecaseOption acp.jax /*g:acp_ignorecaseOption* +g:acp_mappingDriven acp.jax /*g:acp_mappingDriven* diff --git a/vim-plugins/bundle/emmet-vim/doc/tags b/vim-plugins/bundle/emmet-vim/doc/tags new file mode 100644 index 0000000..657a04a --- /dev/null +++ b/vim-plugins/bundle/emmet-vim/doc/tags @@ -0,0 +1,93 @@ +:Emmet emmet.txt /*:Emmet* +:EmmetInstall emmet.txt /*:EmmetInstall* +, emmet.txt /*,* +/ emmet.txt /*\/* +; emmet.txt /*;* +A emmet.txt /*A* +D emmet.txt /*D* +N emmet.txt /*N* +a emmet.txt /*a* +c emmet.txt /*c* +d emmet.txt /*d* +i emmet.txt /*i* +j emmet.txt /*j* +k emmet.txt /*k* +m emmet.txt /*m* +n emmet.txt /*n* +u emmet.txt /*u* +Emmet emmet.txt /*Emmet* +emmet emmet.txt /*emmet* +emmet-# emmet.txt /*emmet-#* +emmet-$ emmet.txt /*emmet-$* +emmet-$# emmet.txt /*emmet-$#* +emmet-() emmet.txt /*emmet-()* +emmet-+ emmet.txt /*emmet-+* +emmet-. emmet.txt /*emmet-.* +emmet-> emmet.txt /*emmet->* +emmet-@ emmet.txt /*emmet-@* +emmet-[] emmet.txt /*emmet-[]* +emmet-^ emmet.txt /*emmet-^* +emmet-abbreviation emmet.txt /*emmet-abbreviation* +emmet-alias emmet.txt /*emmet-alias* +emmet-balance-tag-inward emmet.txt /*emmet-balance-tag-inward* +emmet-balance-tag-outward emmet.txt /*emmet-balance-tag-outward* +emmet-code-pretty emmet.txt /*emmet-code-pretty* +emmet-commands emmet.txt /*emmet-commands* +emmet-contents emmet.txt /*emmet-contents* +emmet-css-expression-syntax emmet.txt /*emmet-css-expression-syntax* +emmet-css-properties emmet.txt /*emmet-css-properties* +emmet-css-units emmet.txt /*emmet-css-units* +emmet-css-values emmet.txt /*emmet-css-values* +emmet-css-vendor-prefixes emmet.txt /*emmet-css-vendor-prefixes* +emmet-custom-snippets emmet.txt /*emmet-custom-snippets* +emmet-customize emmet.txt /*emmet-customize* +emmet-customize-key-mappings emmet.txt /*emmet-customize-key-mappings* +emmet-define-tags-behavior emmet.txt /*emmet-define-tags-behavior* +emmet-expand-abbr emmet.txt /*emmet-expand-abbr* +emmet-expand-word emmet.txt /*emmet-expand-word* +emmet-filter emmet.txt /*emmet-filter* +emmet-filter-c emmet.txt /*emmet-filter-c* +emmet-filter-e emmet.txt /*emmet-filter-e* +emmet-filter-s emmet.txt /*emmet-filter-s* +emmet-filter-t emmet.txt /*emmet-filter-t* +emmet-filters-list emmet.txt /*emmet-filters-list* +emmet-goto-next-point emmet.txt /*emmet-goto-next-point* +emmet-goto-previous-point emmet.txt /*emmet-goto-previous-point* +emmet-html-attr-quote-char emmet.txt /*emmet-html-attr-quote-char* +emmet-html-expression-syntax emmet.txt /*emmet-html-expression-syntax* +emmet-html-implicit-tag-names emmet.txt /*emmet-html-implicit-tag-names* +emmet-html-syntax-attribute-operators emmet.txt /*emmet-html-syntax-attribute-operators* +emmet-html-syntax-elements emmet.txt /*emmet-html-syntax-elements* +emmet-html-syntax-nesting-operators emmet.txt /*emmet-html-syntax-nesting-operators* +emmet-html-syntax-notes emmet.txt /*emmet-html-syntax-notes* +emmet-indent-size emmet.txt /*emmet-indent-size* +emmet-install emmet.txt /*emmet-install* +emmet-introduction emmet.txt /*emmet-introduction* +emmet-links emmet.txt /*emmet-links* +emmet-lorem-ipsum emmet.txt /*emmet-lorem-ipsum* +emmet-make-anchor-url emmet.txt /*emmet-make-anchor-url* +emmet-merge-lines emmet.txt /*emmet-merge-lines* +emmet-quoted-text-url emmet.txt /*emmet-quoted-text-url* +emmet-remove-tag emmet.txt /*emmet-remove-tag* +emmet-snippet emmet.txt /*emmet-snippet* +emmet-split-join-tag emmet.txt /*emmet-split-join-tag* +emmet-star emmet.txt /*emmet-star* +emmet-todo emmet.txt /*emmet-todo* +emmet-toggle-comment emmet.txt /*emmet-toggle-comment* +emmet-tutorial emmet.txt /*emmet-tutorial* +emmet-update-image-size emmet.txt /*emmet-update-image-size* +emmet-update-tag emmet.txt /*emmet-update-tag* +emmet-variables emmet.txt /*emmet-variables* +emmet-wrap-with-abbreviation emmet.txt /*emmet-wrap-with-abbreviation* +emmet-{} emmet.txt /*emmet-{}* +emmet.txt emmet.txt /*emmet.txt* +g:emmet_curl_command emmet.txt /*g:emmet_curl_command* +g:emmet_docroot emmet.txt /*g:emmet_docroot* +g:emmet_html5 emmet.txt /*g:emmet_html5* +g:user_emmet_complete_tag emmet.txt /*g:user_emmet_complete_tag* +g:user_emmet_install_command emmet.txt /*g:user_emmet_install_command* +g:user_emmet_install_global emmet.txt /*g:user_emmet_install_global* +g:user_emmet_leader_key emmet.txt /*g:user_emmet_leader_key* +g:user_emmet_mode emmet.txt /*g:user_emmet_mode* +g:user_emmet_settings emmet.txt /*g:user_emmet_settings* +v_, emmet.txt /*v_,* diff --git a/vim-plugins/bundle/nerdtree/doc/tags b/vim-plugins/bundle/nerdtree/doc/tags index 7b33f32..a3933b0 100644 --- a/vim-plugins/bundle/nerdtree/doc/tags +++ b/vim-plugins/bundle/nerdtree/doc/tags @@ -11,6 +11,7 @@ 'NERDTreeHighlightCursorline' NERD_tree.txt /*'NERDTreeHighlightCursorline'* 'NERDTreeHijackNetrw' NERD_tree.txt /*'NERDTreeHijackNetrw'* 'NERDTreeIgnore' NERD_tree.txt /*'NERDTreeIgnore'* +'NERDTreeMarkBookmarks' NERD_tree.txt /*'NERDTreeMarkBookmarks'* 'NERDTreeMinimalUI' NERD_tree.txt /*'NERDTreeMinimalUI'* 'NERDTreeMouseMode' NERD_tree.txt /*'NERDTreeMouseMode'* 'NERDTreeQuitOnOpen' NERD_tree.txt /*'NERDTreeQuitOnOpen'* @@ -28,6 +29,7 @@ :NERDTreeCWD NERD_tree.txt /*:NERDTreeCWD* :NERDTreeClose NERD_tree.txt /*:NERDTreeClose* :NERDTreeFind NERD_tree.txt /*:NERDTreeFind* +:NERDTreeFocus NERD_tree.txt /*:NERDTreeFocus* :NERDTreeFromBookmark NERD_tree.txt /*:NERDTreeFromBookmark* :NERDTreeMirror NERD_tree.txt /*:NERDTreeMirror* :NERDTreeToggle NERD_tree.txt /*:NERDTreeToggle* diff --git a/vim-plugins/bundle/python-mode/doc/tags b/vim-plugins/bundle/python-mode/doc/tags new file mode 100644 index 0000000..01e1e35 --- /dev/null +++ b/vim-plugins/bundle/python-mode/doc/tags @@ -0,0 +1,121 @@ +'g:pymode' pymode.txt /*'g:pymode'* +'g:pymode_breakpoint' pymode.txt /*'g:pymode_breakpoint'* +'g:pymode_doc' pymode.txt /*'g:pymode_doc'* +'g:pymode_doc_bind' pymode.txt /*'g:pymode_doc_bind'* +'g:pymode_folding' pymode.txt /*'g:pymode_folding'* +'g:pymode_indent' pymode.txt /*'g:pymode_indent'* +'g:pymode_lint' pymode.txt /*'g:pymode_lint'* +'g:pymode_lint_checkers' pymode.txt /*'g:pymode_lint_checkers'* +'g:pymode_lint_cwindow' pymode.txt /*'g:pymode_lint_cwindow'* +'g:pymode_lint_ignore' pymode.txt /*'g:pymode_lint_ignore'* +'g:pymode_lint_message' pymode.txt /*'g:pymode_lint_message'* +'g:pymode_lint_on_fly' pymode.txt /*'g:pymode_lint_on_fly'* +'g:pymode_lint_on_write' pymode.txt /*'g:pymode_lint_on_write'* +'g:pymode_lint_options_mccabe' pymode.txt /*'g:pymode_lint_options_mccabe'* +'g:pymode_lint_options_pep257' pymode.txt /*'g:pymode_lint_options_pep257'* +'g:pymode_lint_options_pep8' pymode.txt /*'g:pymode_lint_options_pep8'* +'g:pymode_lint_options_pyflakes' pymode.txt /*'g:pymode_lint_options_pyflakes'* +'g:pymode_lint_options_pylint' pymode.txt /*'g:pymode_lint_options_pylint'* +'g:pymode_lint_select' pymode.txt /*'g:pymode_lint_select'* +'g:pymode_lint_sort' pymode.txt /*'g:pymode_lint_sort'* +'g:pymode_lint_unmodified' pymode.txt /*'g:pymode_lint_unmodified'* +'g:pymode_motion' pymode.txt /*'g:pymode_motion'* +'g:pymode_options' pymode.txt /*'g:pymode_options'* +'g:pymode_options_colorcolumn' pymode.txt /*'g:pymode_options_colorcolumn'* +'g:pymode_options_max_line_length' pymode.txt /*'g:pymode_options_max_line_length'* +'g:pymode_paths' pymode.txt /*'g:pymode_paths'* +'g:pymode_python' pymode.txt /*'g:pymode_python'* +'g:pymode_quickfix_maxheight' pymode.txt /*'g:pymode_quickfix_maxheight'* +'g:pymode_quickfix_minheight' pymode.txt /*'g:pymode_quickfix_minheight'* +'g:pymode_rope' pymode.txt /*'g:pymode_rope'* +'g:pymode_rope_autoimport' pymode.txt /*'g:pymode_rope_autoimport'* +'g:pymode_rope_autoimport_bind' pymode.txt /*'g:pymode_rope_autoimport_bind'* +'g:pymode_rope_autoimport_modules' pymode.txt /*'g:pymode_rope_autoimport_modules'* +'g:pymode_rope_complete_on_dot' pymode.txt /*'g:pymode_rope_complete_on_dot'* +'g:pymode_rope_completion' pymode.txt /*'g:pymode_rope_completion'* +'g:pymode_rope_completion_bind' pymode.txt /*'g:pymode_rope_completion_bind'* +'g:pymode_rope_extract_method_bind' pymode.txt /*'g:pymode_rope_extract_method_bind'* +'g:pymode_rope_extract_variable_bind' pymode.txt /*'g:pymode_rope_extract_variable_bind'* +'g:pymode_rope_goto_definition_bind' pymode.txt /*'g:pymode_rope_goto_definition_bind'* +'g:pymode_rope_goto_definition_cmd' pymode.txt /*'g:pymode_rope_goto_definition_cmd'* +'g:pymode_rope_lookup_project' pymode.txt /*'g:pymode_rope_lookup_project'* +'g:pymode_rope_module_to_package_bind' pymode.txt /*'g:pymode_rope_module_to_package_bind'* +'g:pymode_rope_organize_imports_bind' pymode.txt /*'g:pymode_rope_organize_imports_bind'* +'g:pymode_rope_project_root' pymode.txt /*'g:pymode_rope_project_root'* +'g:pymode_rope_rename_bind' pymode.txt /*'g:pymode_rope_rename_bind'* +'g:pymode_rope_rename_module_bind' pymode.txt /*'g:pymode_rope_rename_module_bind'* +'g:pymode_rope_ropefolder' pymode.txt /*'g:pymode_rope_ropefolder'* +'g:pymode_rope_show_doc_bind' pymode.txt /*'g:pymode_rope_show_doc_bind'* +'g:pymode_run' pymode.txt /*'g:pymode_run'* +'g:pymode_run_bind' pymode.txt /*'g:pymode_run_bind'* +'g:pymode_signs' pymode.txt /*'g:pymode_signs'* +'g:pymode_syntax' pymode.txt /*'g:pymode_syntax'* +'g:pymode_syntax_all' pymode.txt /*'g:pymode_syntax_all'* +'g:pymode_syntax_builtin_objs' pymode.txt /*'g:pymode_syntax_builtin_objs'* +'g:pymode_syntax_builtin_types' pymode.txt /*'g:pymode_syntax_builtin_types'* +'g:pymode_syntax_docstrings' pymode.txt /*'g:pymode_syntax_docstrings'* +'g:pymode_syntax_doctests' pymode.txt /*'g:pymode_syntax_doctests'* +'g:pymode_syntax_highlight_async_await' pymode.txt /*'g:pymode_syntax_highlight_async_await'* +'g:pymode_syntax_highlight_equal_operator' pymode.txt /*'g:pymode_syntax_highlight_equal_operator'* +'g:pymode_syntax_highlight_exceptions' pymode.txt /*'g:pymode_syntax_highlight_exceptions'* +'g:pymode_syntax_highlight_self' pymode.txt /*'g:pymode_syntax_highlight_self'* +'g:pymode_syntax_highlight_stars_operator' pymode.txt /*'g:pymode_syntax_highlight_stars_operator'* +'g:pymode_syntax_indent_errors' pymode.txt /*'g:pymode_syntax_indent_errors'* +'g:pymode_syntax_print_as_function' pymode.txt /*'g:pymode_syntax_print_as_function'* +'g:pymode_syntax_slow_sync' pymode.txt /*'g:pymode_syntax_slow_sync'* +'g:pymode_syntax_space_errors' pymode.txt /*'g:pymode_syntax_space_errors'* +'g:pymode_syntax_string_format' pymode.txt /*'g:pymode_syntax_string_format'* +'g:pymode_syntax_string_formatting' pymode.txt /*'g:pymode_syntax_string_formatting'* +'g:pymode_syntax_string_templates' pymode.txt /*'g:pymode_syntax_string_templates'* +'g:pymode_trim_whitespaces' pymode.txt /*'g:pymode_trim_whitespaces'* +'g:pymode_virtualenv' pymode.txt /*'g:pymode_virtualenv'* +'g:pymode_virtualenv_path' pymode.txt /*'g:pymode_virtualenv_path'* +'g:pymode_warnings' pymode.txt /*'g:pymode_warnings'* +.ropeproject pymode.txt /*.ropeproject* +:PymodeDoc pymode.txt /*:PymodeDoc* +:PymodeLint pymode.txt /*:PymodeLint* +:PymodeLintAuto pymode.txt /*:PymodeLintAuto* +:PymodeLintToggle pymode.txt /*:PymodeLintToggle* +:PymodeRopeAutoImport pymode.txt /*:PymodeRopeAutoImport* +:PymodeRopeModuleToPackage pymode.txt /*:PymodeRopeModuleToPackage* +:PymodeRopeNewProject pymode.txt /*:PymodeRopeNewProject* +:PymodeRopeRedo pymode.txt /*:PymodeRopeRedo* +:PymodeRopeRegenerate pymode.txt /*:PymodeRopeRegenerate* +:PymodeRopeRenameModule pymode.txt /*:PymodeRopeRenameModule* +:PymodeRopeUndo pymode.txt /*:PymodeRopeUndo* +:PymodeRun pymode.txt /*:PymodeRun* +:PymodeVirtualenv pymode.txt /*:PymodeVirtualenv* +g pymode.txt /*g* +pymode pymode.txt /*pymode* +pymode-breakpoints pymode.txt /*pymode-breakpoints* +pymode-common pymode.txt /*pymode-common* +pymode-completion pymode.txt /*pymode-completion* +pymode-contents pymode.txt /*pymode-contents* +pymode-credits pymode.txt /*pymode-credits* +pymode-documentation pymode.txt /*pymode-documentation* +pymode-faq pymode.txt /*pymode-faq* +pymode-features pymode.txt /*pymode-features* +pymode-folding pymode.txt /*pymode-folding* +pymode-indent pymode.txt /*pymode-indent* +pymode-intro pymode.txt /*pymode-intro* +pymode-license pymode.txt /*pymode-license* +pymode-lint pymode.txt /*pymode-lint* +pymode-lint-options pymode.txt /*pymode-lint-options* +pymode-motion pymode.txt /*pymode-motion* +pymode-motion-keys pymode.txt /*pymode-motion-keys* +pymode-python-version pymode.txt /*pymode-python-version* +pymode-rope pymode.txt /*pymode-rope* +pymode-rope-extract pymode.txt /*pymode-rope-extract* +pymode-rope-findit pymode.txt /*pymode-rope-findit* +pymode-rope-move pymode.txt /*pymode-rope-move* +pymode-rope-redo pymode.txt /*pymode-rope-redo* +pymode-rope-refactoring pymode.txt /*pymode-rope-refactoring* +pymode-rope-slow pymode.txt /*pymode-rope-slow* +pymode-rope-undo pymode.txt /*pymode-rope-undo* +pymode-rope-use pymode.txt /*pymode-rope-use* +pymode-run pymode.txt /*pymode-run* +pymode-syntax pymode.txt /*pymode-syntax* +pymode-virtualenv pymode.txt /*pymode-virtualenv* +pymode.txt pymode.txt /*pymode.txt* +python-mode pymode.txt /*python-mode* +python-mode.txt pymode.txt /*python-mode.txt* diff --git a/vim-plugins/bundle/supertab/doc/tags b/vim-plugins/bundle/supertab/doc/tags new file mode 100644 index 0000000..0f98c94 --- /dev/null +++ b/vim-plugins/bundle/supertab/doc/tags @@ -0,0 +1,42 @@ +SuperTabChain supertab.txt /*SuperTabChain* +SuperTabSetDefaultCompletionType supertab.txt /*SuperTabSetDefaultCompletionType* +b:SuperTabContextTextMemberPatterns supertab.txt /*b:SuperTabContextTextMemberPatterns* +b:SuperTabContextTextOmniPrecedence supertab.txt /*b:SuperTabContextTextOmniPrecedence* +g:SuperTabClosePreviewOnPopupClose supertab.txt /*g:SuperTabClosePreviewOnPopupClose* +g:SuperTabCompleteCase supertab.txt /*g:SuperTabCompleteCase* +g:SuperTabCompletionContexts supertab.txt /*g:SuperTabCompletionContexts* +g:SuperTabContextDefaultCompletionType supertab.txt /*g:SuperTabContextDefaultCompletionType* +g:SuperTabContextTextFileTypeExclusions supertab.txt /*g:SuperTabContextTextFileTypeExclusions* +g:SuperTabContextTextMemberPatterns supertab.txt /*g:SuperTabContextTextMemberPatterns* +g:SuperTabContextTextOmniPrecedence supertab.txt /*g:SuperTabContextTextOmniPrecedence* +g:SuperTabCrMapping supertab.txt /*g:SuperTabCrMapping* +g:SuperTabDefaultCompletionType supertab.txt /*g:SuperTabDefaultCompletionType* +g:SuperTabLongestEnhanced supertab.txt /*g:SuperTabLongestEnhanced* +g:SuperTabLongestHighlight supertab.txt /*g:SuperTabLongestHighlight* +g:SuperTabMappingBackward supertab.txt /*g:SuperTabMappingBackward* +g:SuperTabMappingForward supertab.txt /*g:SuperTabMappingForward* +g:SuperTabMappingTabLiteral supertab.txt /*g:SuperTabMappingTabLiteral* +g:SuperTabNoCompleteAfter supertab.txt /*g:SuperTabNoCompleteAfter* +g:SuperTabNoCompleteBefore supertab.txt /*g:SuperTabNoCompleteBefore* +g:SuperTabRetainCompletionDuration supertab.txt /*g:SuperTabRetainCompletionDuration* +supertab supertab.txt /*supertab* +supertab-closepreviewonpopupclose supertab.txt /*supertab-closepreviewonpopupclose* +supertab-completecase supertab.txt /*supertab-completecase* +supertab-completionchaining supertab.txt /*supertab-completionchaining* +supertab-completioncontexts supertab.txt /*supertab-completioncontexts* +supertab-contextdefault supertab.txt /*supertab-contextdefault* +supertab-contextdiscover supertab.txt /*supertab-contextdiscover* +supertab-contextexample supertab.txt /*supertab-contextexample* +supertab-contexttext supertab.txt /*supertab-contexttext* +supertab-crmapping supertab.txt /*supertab-crmapping* +supertab-defaultcompletion supertab.txt /*supertab-defaultcompletion* +supertab-duration supertab.txt /*supertab-duration* +supertab-forwardbackward supertab.txt /*supertab-forwardbackward* +supertab-intro supertab.txt /*supertab-intro* +supertab-longestenhanced supertab.txt /*supertab-longestenhanced* +supertab-longesthighlight supertab.txt /*supertab-longesthighlight* +supertab-mappingtabliteral supertab.txt /*supertab-mappingtabliteral* +supertab-options supertab.txt /*supertab-options* +supertab-preventcomplete supertab.txt /*supertab-preventcomplete* +supertab-usage supertab.txt /*supertab-usage* +supertab.txt supertab.txt /*supertab.txt* diff --git a/vim-plugins/bundle/tabular/LICENSE.md b/vim-plugins/bundle/tabular/LICENSE.md new file mode 100644 index 0000000..2cc76e9 --- /dev/null +++ b/vim-plugins/bundle/tabular/LICENSE.md @@ -0,0 +1,24 @@ +Copyright (c) 2016, Matthew J. Wozniski +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN +NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vim-plugins/bundle/tabular/README.md b/vim-plugins/bundle/tabular/README.md new file mode 100644 index 0000000..adbfeb0 --- /dev/null +++ b/vim-plugins/bundle/tabular/README.md @@ -0,0 +1,29 @@ +Tabular +============== +Sometimes, it's useful to line up text. Naturally, it's nicer to have the +computer do this for you, since aligning things by hand quickly becomes +unpleasant. While there are other plugins for aligning text, the ones I've +tried are either impossibly difficult to understand and use, or too simplistic +to handle complicated tasks. This plugin aims to make the easy things easy +and the hard things possible, without providing an unnecessarily obtuse +interface. It's still a work in progress, and criticisms are welcome. + +See [Aligning Text with Tabular.vim](http://vimcasts.org/episodes/aligning-text-with-tabular-vim/) +for a screencast that shows how Tabular.vim works. + +See [doc/Tabular.txt](http://raw.github.com/godlygeek/tabular/master/doc/Tabular.txt) +for detailed documentation. + +Installation +============== +If you don't have a preferred installation method, I recommend installing +[pathogen.vim](https://github.com/tpope/vim-pathogen), and then simply +copy and paste: + + mkdir -p ~/.vim/bundle + cd ~/.vim/bundle + git clone git://github.com/godlygeek/tabular.git + +Once help tags have been generated (either using Pathogen's `:Helptags` +command, or by pointing vim's `:helptags` command at the directory where you +installed Tabular), you can view the manual with `:help tabular`. diff --git a/vim-plugins/bundle/tabular/after/plugin/TabularMaps.vim b/vim-plugins/bundle/tabular/after/plugin/TabularMaps.vim new file mode 100644 index 0000000..998346f --- /dev/null +++ b/vim-plugins/bundle/tabular/after/plugin/TabularMaps.vim @@ -0,0 +1,73 @@ +" Copyright (c) 2016, Matthew J. Wozniski +" All rights reserved. +" +" Redistribution and use in source and binary forms, with or without +" modification, are permitted provided that the following conditions are met: +" * Redistributions of source code must retain the above copyright notice, +" this list of conditions and the following disclaimer. +" * Redistributions in binary form must reproduce the above copyright +" notice, this list of conditions and the following disclaimer in the +" documentation and/or other materials provided with the distribution. +" * The names of the contributors may not be used to endorse or promote +" products derived from this software without specific prior written +" permission. +" +" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS +" OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN +" NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, +" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +" OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +" EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +if !exists(':Tabularize') || get(g:, 'no_default_tabular_maps', 0) + finish " Tabular.vim wasn't loaded or the default maps are unwanted +endif + +let s:save_cpo = &cpo +set cpo&vim + +AddTabularPattern! assignment /[|&+*/%<>=!~-]\@!=]=\|=\~\)\@![|&+*/%<>=!~-]*=/l1r1 +AddTabularPattern! two_spaces / /l0 + +AddTabularPipeline! multiple_spaces / / map(a:lines, "substitute(v:val, ' *', ' ', 'g')") | tabular#TabularizeStrings(a:lines, ' ', 'l0') + +AddTabularPipeline! argument_list /(.*)/ map(a:lines, 'substitute(v:val, ''\s*\([(,)]\)\s*'', ''\1'', ''g'')') + \ | tabular#TabularizeStrings(a:lines, '[(,)]', 'l0') + \ | map(a:lines, 'substitute(v:val, ''\(\s*\),'', '',\1 '', "g")') + \ | map(a:lines, 'substitute(v:val, ''\s*)'', ")", "g")') + +function! SplitCDeclarations(lines) + let rv = [] + for line in a:lines + " split the line into declaractions + let split = split(line, '\s*[,;]\s*') + " separate the type from the first declaration + let type = substitute(split[0], '\%(\%([&*]\s*\)*\)\=\k\+$', '', '') + " add the ; back on every declaration + call map(split, 'v:val . ";"') + " add the first element to the return as-is, and remove it from the list + let rv += [ remove(split, 0) ] + " transform the other elements by adding the type on at the beginning + call map(split, 'type . v:val') + " and add them all to the return + let rv += split + endfor + return rv +endfunction + +AddTabularPipeline! split_declarations /,.*;/ SplitCDeclarations(a:lines) + +AddTabularPattern! ternary_operator /^.\{-}\zs?\|:/l1 + +AddTabularPattern! cpp_io /<<\|>>/l1 + +AddTabularPattern! pascal_assign /:=/l1 + +AddTabularPattern! trailing_c_comments /\/\*\|\*\/\|\/\//l1 + +let &cpo = s:save_cpo +unlet s:save_cpo diff --git a/vim-plugins/bundle/tabular/autoload/tabular.vim b/vim-plugins/bundle/tabular/autoload/tabular.vim new file mode 100644 index 0000000..f60a73c --- /dev/null +++ b/vim-plugins/bundle/tabular/autoload/tabular.vim @@ -0,0 +1,409 @@ +" Tabular: Align columnar data using regex-designated column boundaries +" Maintainer: Matthew Wozniski (godlygeek@gmail.com) +" Date: Thu, 03 May 2012 20:49:32 -0400 +" Version: 1.0 +" +" Long Description: +" Sometimes, it's useful to line up text. Naturally, it's nicer to have the +" computer do this for you, since aligning things by hand quickly becomes +" unpleasant. While there are other plugins for aligning text, the ones I've +" tried are either impossibly difficult to understand and use, or too simplistic +" to handle complicated tasks. This plugin aims to make the easy things easy +" and the hard things possible, without providing an unnecessarily obtuse +" interface. It's still a work in progress, and criticisms are welcome. +" +" License: +" Copyright (c) 2012, Matthew J. Wozniski +" All rights reserved. +" +" Redistribution and use in source and binary forms, with or without +" modification, are permitted provided that the following conditions are met: +" * Redistributions of source code must retain the above copyright notice, +" this list of conditions and the following disclaimer. +" * Redistributions in binary form must reproduce the above copyright +" notice, this list of conditions and the following disclaimer in the +" documentation and/or other materials provided with the distribution. +" * The names of the contributors may not be used to endorse or promote +" products derived from this software without specific prior written +" permission. +" +" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS +" OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN +" NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, +" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +" OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +" EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +" Stupid vimscript crap {{{1 +let s:savecpo = &cpo +set cpo&vim + +" Private Functions {{{1 + +" Return the number of bytes in a string after expanding tabs to spaces. {{{2 +" This expansion is done based on the current value of 'tabstop' +if exists('*strdisplaywidth') + " Needs vim 7.3 + let s:Strlen = function("strdisplaywidth") +else + function! s:Strlen(string) + " Implement the tab handling part of strdisplaywidth for vim 7.2 and + " earlier - not much that can be done about handling doublewidth + " characters. + let rv = 0 + let i = 0 + + for char in split(a:string, '\zs') + if char == "\t" + let rv += &ts - i + let i = 0 + else + let rv += 1 + let i = (i + 1) % &ts + endif + endfor + + return rv + endfunction +endif + +" Align a string within a field {{{2 +" These functions do not trim leading and trailing spaces. + +" Right align 'string' in a field of size 'fieldwidth' +function! s:Right(string, fieldwidth) + let spaces = a:fieldwidth - s:Strlen(a:string) + return matchstr(a:string, '^\s*') . repeat(" ", spaces) . substitute(a:string, '^\s*', '', '') +endfunction + +" Left align 'string' in a field of size 'fieldwidth' +function! s:Left(string, fieldwidth) + let spaces = a:fieldwidth - s:Strlen(a:string) + return a:string . repeat(" ", spaces) +endfunction + +" Center align 'string' in a field of size 'fieldwidth' +function! s:Center(string, fieldwidth) + let spaces = a:fieldwidth - s:Strlen(a:string) + let right = spaces / 2 + let left = right + (right * 2 != spaces) + return repeat(" ", left) . a:string . repeat(" ", right) +endfunction + +" Remove spaces around a string {{{2 + +" Remove all trailing spaces from a string. +function! s:StripTrailingSpaces(string) + return matchstr(a:string, '^.\{-}\ze\s*$') +endfunction + +" Remove all leading spaces from a string. +function! s:StripLeadingSpaces(string) + return matchstr(a:string, '^\s*\zs.*$') +endfunction + +" Split a string into fields and delimiters {{{2 +" Like split(), but include the delimiters as elements +" All odd numbered elements are delimiters +" All even numbered elements are non-delimiters (including zero) +function! s:SplitDelim(string, delim) + let rv = [] + let beg = 0 + + let len = len(a:string) + let searchoff = 0 + + while 1 + let mid = match(a:string, a:delim, beg + searchoff, 1) + if mid == -1 || mid == len + break + endif + + let matchstr = matchstr(a:string, a:delim, beg + searchoff, 1) + let length = strlen(matchstr) + + if length == 0 && beg == mid + " Zero-length match for a zero-length delimiter - advance past it + let searchoff += 1 + continue + endif + + if beg == mid + let rv += [ "" ] + else + let rv += [ a:string[beg : mid-1] ] + endif + + let rv += [ matchstr ] + + let beg = mid + length + let searchoff = 0 + endwhile + + let rv += [ strpart(a:string, beg) ] + + return rv +endfunction + +" Replace lines from `start' to `start + len - 1' with the given strings. {{{2 +" If more lines are needed to show all strings, they will be added. +" If there are too few strings to fill all lines, lines will be removed. +function! s:SetLines(start, len, strings) + if a:start > line('$') + 1 || a:start < 1 + throw "Invalid start line!" + endif + + if len(a:strings) > a:len + let fensave = &fen + let view = winsaveview() + call append(a:start + a:len - 1, repeat([''], len(a:strings) - a:len)) + call winrestview(view) + let &fen = fensave + elseif len(a:strings) < a:len + let fensave = &fen + let view = winsaveview() + sil exe (a:start + len(a:strings)) . ',' . (a:start + a:len - 1) . 'd_' + call winrestview(view) + let &fen = fensave + endif + + call setline(a:start, a:strings) +endfunction + +" Runs the given commandstring argument as an expression. {{{2 +" The commandstring expression is expected to reference the a:lines argument. +" If the commandstring expression returns a list the items of that list will +" replace the items in a:lines, otherwise the expression is assumed to have +" modified a:lines itself. +function! s:FilterString(lines, commandstring) + exe 'let rv = ' . a:commandstring + + if type(rv) == type(a:lines) && rv isnot a:lines + call filter(a:lines, 0) + call extend(a:lines, rv) + endif +endfunction + +" Public API {{{1 + +if !exists("g:tabular_default_format") + let g:tabular_default_format = "l1" +endif + +let s:formatelempat = '\%([lrc]\d\+\)' + +function! tabular#ElementFormatPattern() + return s:formatelempat +endfunction + +" Given a list of strings and a delimiter, split each string on every +" occurrence of the delimiter pattern, format each element according to either +" the provided format (optional) or the default format, and join them back +" together with enough space padding to guarantee that the nth delimiter of +" each string is aligned. +function! tabular#TabularizeStrings(strings, delim, ...) + if a:0 > 1 + echoerr "TabularizeStrings accepts only 2 or 3 arguments (got ".(a:0+2).")" + return 1 + endif + + let formatstr = (a:0 ? a:1 : g:tabular_default_format) + + if formatstr !~? s:formatelempat . '\+' + echoerr "Tabular: Invalid format \"" . formatstr . "\" specified!" + return 1 + endif + + let format = split(formatstr, s:formatelempat . '\zs') + + let lines = map(a:strings, 's:SplitDelim(v:val, a:delim)') + + " Strip spaces + " - Only from non-delimiters; spaces in delimiters must have been matched + " intentionally + " - Don't strip leading spaces from the first element; we like indenting. + for line in lines + if len(line) == 1 && s:do_gtabularize + continue " Leave non-matching lines unchanged for GTabularize + endif + + if line[0] !~ '^\s*$' + let line[0] = s:StripTrailingSpaces(line[0]) + endif + if len(line) >= 3 + for i in range(2, len(line)-1, 2) + let line[i] = s:StripLeadingSpaces(s:StripTrailingSpaces(line[i])) + endfor + endif + endfor + + " Find the max length of each field + let maxes = [] + for line in lines + if len(line) == 1 && s:do_gtabularize + continue " non-matching lines don't affect field widths for GTabularize + endif + + for i in range(len(line)) + if i == len(maxes) + let maxes += [ s:Strlen(line[i]) ] + else + let maxes[i] = max( [ maxes[i], s:Strlen(line[i]) ] ) + endif + endfor + endfor + + let lead_blank = empty(filter(copy(lines), 'v:val[0] =~ "\\S"')) + + " Concatenate the fields, according to the format pattern. + for idx in range(len(lines)) + let line = lines[idx] + + if len(line) == 1 && s:do_gtabularize + let lines[idx] = line[0] " GTabularize doesn't change non-matching lines + continue + endif + + for i in range(len(line)) + let how = format[i % len(format)][0] + let pad = format[i % len(format)][1:-1] + + if how =~? 'l' + let field = s:Left(line[i], maxes[i]) + elseif how =~? 'r' + let field = s:Right(line[i], maxes[i]) + elseif how =~? 'c' + let field = s:Center(line[i], maxes[i]) + endif + + let line[i] = field . (lead_blank && i == 0 ? '' : repeat(" ", pad)) + endfor + + let lines[idx] = s:StripTrailingSpaces(join(line, '')) + endfor +endfunction + +" Apply 0 or more filters, in sequence, to selected text in the buffer {{{2 +" The lines to be filtered are determined as follows: +" If the function is called with a range containing multiple lines, then +" those lines will be used as the range. +" If the function is called with no range or with a range of 1 line, then +" if GTabularize mode is being used, +" the range will not be adjusted +" if "includepat" is not specified, +" that 1 line will be filtered, +" if "includepat" is specified and that line does not match it, +" no lines will be filtered +" if "includepat" is specified and that line does match it, +" all contiguous lines above and below the specified line matching the +" pattern will be filtered. +" +" The remaining arguments must each be a filter to apply to the text. +" Each filter must either be a String evaluating to a function to be called. +function! tabular#PipeRange(includepat, ...) range + exe a:firstline . ',' . a:lastline + \ . 'call tabular#PipeRangeWithOptions(a:includepat, a:000, {})' +endfunction + +" Extended version of tabular#PipeRange, which +" 1) Takes the list of filters as an explicit list rather than as varargs +" 2) Supports passing a dictionary of options to control the routine. +" Currently, the only supported option is 'mode', which determines whether +" to behave as :Tabularize or as :GTabularize +" This allows me to add new features here without breaking API compatibility +" in the future. +function! tabular#PipeRangeWithOptions(includepat, filterlist, options) range + let top = a:firstline + let bot = a:lastline + + let s:do_gtabularize = (get(a:options, 'mode', '') ==# 'GTabularize') + + if !s:do_gtabularize + " In the default mode, apply range extension logic + if a:includepat != '' && top == bot + if top < 0 || top > line('$') || getline(top) !~ a:includepat + return + endif + while top > 1 && getline(top-1) =~ a:includepat + let top -= 1 + endwhile + while bot < line('$') && getline(bot+1) =~ a:includepat + let bot += 1 + endwhile + endif + endif + + let lines = map(range(top, bot), 'getline(v:val)') + + for filter in a:filterlist + if type(filter) != type("") + echoerr "PipeRange: Bad filter: " . string(filter) + endif + + call s:FilterString(lines, filter) + + unlet filter + endfor + + call s:SetLines(top, bot - top + 1, lines) +endfunction + +" Part of the public interface so interested pipelines can query this and +" adjust their behavior appropriately. +function! tabular#DoGTabularize() + return s:do_gtabularize +endfunction + +function! s:SplitDelimTest(string, delim, expected) + let result = s:SplitDelim(a:string, a:delim) + + if result !=# a:expected + echomsg 'Test failed!' + echomsg ' string=' . string(a:string) . ' delim=' . string(a:delim) + echomsg ' Returned=' . string(result) + echomsg ' Expected=' . string(a:expected) + endif +endfunction + +function! tabular#SplitDelimUnitTest() + let assignment = '[|&+*/%<>=!~-]\@!=]=\|=\~\)\@![|&+*/%<>=!~-]*=' + let two_spaces = ' ' + let ternary_operator = '^.\{-}\zs?\|:' + let cpp_io = '<<\|>>' + let pascal_assign = ':=' + let trailing_c_comments = '\/\*\|\*\/\|\/\/' + + call s:SplitDelimTest('a+=b', assignment, ['a', '+=', 'b']) + call s:SplitDelimTest('a-=b', assignment, ['a', '-=', 'b']) + call s:SplitDelimTest('a!=b', assignment, ['a!=b']) + call s:SplitDelimTest('a==b', assignment, ['a==b']) + call s:SplitDelimTest('a&=b', assignment, ['a', '&=', 'b']) + call s:SplitDelimTest('a|=b', assignment, ['a', '|=', 'b']) + call s:SplitDelimTest('a=b=c', assignment, ['a', '=', 'b', '=', 'c']) + + call s:SplitDelimTest('a b c', two_spaces, ['a', ' ', 'b', ' ', 'c']) + call s:SplitDelimTest('a b c', two_spaces, ['a b', ' ', ' c']) + call s:SplitDelimTest('ab c', two_spaces, ['ab', ' ', '', ' ', 'c']) + + call s:SplitDelimTest('a?b:c', ternary_operator, ['a', '?', 'b', ':', 'c']) + + call s:SplitDelimTest('a< + :let g:tabular_loaded = 1 + +============================================================================== +1. Description *tabular-intro* + +Sometimes, it's useful to line up text. Naturally, it's nicer to have the +computer do this for you, since aligning things by hand quickly becomes +unpleasant. While there are other plugins for aligning text, the ones I've +tried are either impossibly difficult to understand and use, or too simplistic +to handle complicated tasks. This plugin aims to make the easy things easy +and the hard things possible, without providing an unnecessarily obtuse +interface. It's still a work in progress, and criticisms are welcome. + +============================================================================== +2. Walkthrough *tabular-walkthrough* *:Tabularize* + +Tabular's commands are based largely on regular expressions. The basic +technique used by Tabular is taking some regex to match field delimiters, +splitting the input lines at those delimiters, trimming unnecessary spaces +from the non-delimiter parts, padding the non-delimiter parts of the lines +with spaces to make them the same length, and joining things back together +again. + +For instance, consider starting with the following lines: +> + Some short phrase,some other phrase + A much longer phrase here,and another long phrase +< +Let's say we want to line these lines up at the commas. We can tell +Tabularize to do this by passing a pattern matching , to the Tabularize +command: +> + :Tabularize /, + + Some short phrase , some other phrase + A much longer phrase here , and another long phrase +< +I encourage you to try copying those lines to another buffer and trying to +call :Tabularize. You'll want to take notice of two things quickly: First, +instead of requiring a range, Tabularize tries to figure out what you want to +happen. Since it knows that you want to act on lines matching a comma, it +will look upwards and downwards for lines around the current line that match a +comma, and consider all contiguous lines matching the pattern to be the range +to be acted upon. You can always override this by specifying a range, though. + +The second thing you should notice is that you'll almost certainly be able to +abbreviate :Tabularize to :Tab - using this form in mappings and scripts is +discouraged as it will make conflicts with other scripts more likely, but for +interactive use it's a nice timesaver. Another convenience feature is that +running :Tabularize without providing a new pattern will cause it to reuse the +last pattern it was called with. + +So, anyway, now the commas line up. Splitting the lines on commas, Tabular +realized that 'Some short phrase' would need to be padded with spaces to match +the length of 'A much longer phrase here', and it did that before joining the +lines back together. You'll also notice that, in addition to the spaces +inserting for padding, extra spaces were inserted between fields. That's +because by default, Tabular prints things left-aligned with one space between +fields. If you wanted to print things right-aligned with no spaces between +fields, you would provide a different format to the Tabularize command: +> + :Tabularize /,/r0 + + Some short phrase, some other phrase + A much longer phrase here,and another long phrase +< +A format specifier is either l, r, or c, followed by one or more digits. If +the letter is l, the field will be left aligned, similarly for r and right +aligning and c and center aligning. The number following the letter is the +number of spaces padding to insert before the start of the next field. +Multiple format specifiers can be added to the same command - each field will +be printed with the next format specifier in the list; when they all have been +used the first will be used again, and so on. So, the last command right +aligned every field, then inserted 0 spaces of padding before the next field. +What if we wanted to right align the text before the comma, and left align the +text after the comma? The command would look like this: +> + :Tabularize /,/r1c1l0 + + Some short phrase , some other phrase + A much longer phrase here , and another long phrase +< +That command would be read as "Align the matching text, splitting fields on +commas. Print everything before the first comma right aligned, then 1 space, +then the comma center aligned, then 1 space, then everything after the comma +left aligned." Notice that the alignment of the field the comma is in is +irrelevant - since it's only 1 cell wide, it looks the same whether it's right, +left, or center aligned. Also notice that the 0 padding spaces specified for +the 3rd field are unused - but they would be used if there were enough fields +to require looping through the fields again. For instance: +> + abc,def,ghi + a,b + a,b,c + + :Tabularize /,/r1c1l0 + + abc , def, ghi + a , b + a , b , c +< +Notice that now, the format pattern has been reused; field 4 (the second comma) +is right aligned, field 5 is center aligned. No spaces were inserted between +the 3rd field (containing "def") and the 4th field (the second comma) because +the format specified 'l0'. + +But, what if you only wanted to act on the first comma on the line, rather than +all of the commas on the line? Let's say we want everything before the first +comma right aligned, then the comma, then everything after the comma left +aligned: +> + abc,def,ghi + a,b + a,b,c + + :Tabularize /^[^,]*\zs,/r0c0l0 + + abc,def,ghi + a,b + a,b,c +< +Here, we used a Vim regex that would only match the first comma on the line. +It matches the beginning of the line, followed by all the non-comma characters +up to the first comma, and then forgets about what it matched so far and +pretends that the match starts exactly at the comma. + +But, now that this command does exactly what we want it to, it's become pretty +unwieldy. It would be unpleasant to need to type that more than once or +twice. The solution is to assign a name to it. +> + :AddTabularPattern first_comma /^[^,]*\zs,/r0c0l0 +< +Now, typing ":Tabularize first_comma" will do the same thing as typing the +whole pattern out each time. Of course this is more useful if you store the +name in a file to be used later. + +NOTE: In order to make these new commands available every time vim starts, +you'll need to put those new commands into a .vim file in a plugin directory +somewhere in your 'runtimepath'. In order to make sure that Tabular.vim has +already been loaded before your file tries to use :AddTabularPattern or +:AddTabularPipeline, the new file should be installed in an after/plugin +directory in 'runtimepath'. In general, it will be safe to find out where the +TabularMaps.vim plugin was installed, and place other files extending +Tabular.vim in the same directory as TabularMaps.vim. For more information, +and some suggested best practices, check out the |tabular-scripting| section. + +Lastly, we'll approach the case where tabular cannot achieve your desired goal +just by splitting lines appart, trimming whitespace, padding with whitespace, +and rejoining the lines. As an example, consider the multiple_spaces command +from TabularMaps.vim. The goal is to split using two or more spaces as a +field delimiter, and join fields back together, properly lined up, with only +two spaces between the end of each field and the beginning of the next. +Unfortunately, Tabular can't do this with only the commands we know so far: +> + :Tabularize / / +< +The above function won't work, because it will consider "a b" as 5 fields +delimited by two pairs of 2 spaces ( 'a', ' ', '', ' ', 'b' ) instead of as +3 fields delimited by one set of 2 or more spaces ( 'a', ' ', 'b' ). +> + :Tabularize / \+/ +< +The above function won't work either, because it will leave the delimiter as 4 +spaces when used against "a b", meaning that we would fail at our goal of +collapsing everything down to two spaces between fields. So, we need a new +command to get around this: +> + :AddTabularPipeline multiple_spaces / \{2,}/ + \ map(a:lines, "substitute(v:val, ' \{2,}', ' ', 'g')") + \ | tabular#TabularizeStrings(a:lines, ' ', 'l0') +< +Yeah. I know it looks complicated. Bear with me. I probably will try to add +in some shortcuts for this syntax, but this verbose will be guaranteed to +always work. + +You should already recognize the name being assigned. The next thing to +happen is / \{2,}/ which is a pattern specifying which lines should +automatically be included in the range when no range is given. Without this, +there would be no pattern to use for extending the range. Everything after +that is a | separated list of expressions to be evaluated. In the context in +which they will be evaluated, a:lines will be set to a List of Strings +containing the text of the lines being filtered as they procede through the +pipeline you've set up. The \ at the start of the lines are just vim's line +continuation marker; you needn't worry much about them. So, the first +expression in the pipeline transforms each line by replacing every instance of +2 or more spaces with exactly two spaces. The second command in the pipeline +performs the equivalent of ":Tabularize / /l0"; the only difference is that +it is operating on a List of Strings rather than text in the buffer. At the +end of the pipeline, the Strings in the modified a:lines (or the return value +of the last expression in the pipeline, if it returns a List) will replace the +chosen range. + +============================================================================== +3. Extending *tabular-scripting* + +As mentioned above, the most important consideration when extending Tabular +with new maps or commands is that your plugin must be loaded after Tabular.vim +has finished loading, and only if Tabular.vim has loaded successfully. The +easiest approach to making sure it loads after Tabular.vim is simply putting +the new file (we'll call it "tabular_extra.vim" as an example) into an +"after/plugin/" directory in 'runtimepath', for instance: +> + ~/.vim/after/plugin/tabular_extra.vim +< +The default set of mappings, found in "TabularMaps.vim", is installed in +the after/plugin/ subdirectory of whatever directory Tabular was installed to. + +The other important consideration is making sure that your commands are only +called if Tabular.vim was actually loaded. The easiest way to do this is by +checking for the existence of the :Tabularize command at the start of your +plugin. A short example plugin would look like this: +> + " after/plugin/my_tabular_commands.vim + " Provides extra :Tabularize commands + + if !exists(':Tabularize') + finish " Give up here; the Tabular plugin musn't have been loaded + endif + + " Make line wrapping possible by resetting the 'cpo' option, first saving it + let s:save_cpo = &cpo + set cpo&vim + + AddTabularPattern! asterisk /*/l1 + + AddTabularPipeline! remove_leading_spaces /^ / + \ map(a:lines, "substitute(v:val, '^ *', '', '')") + + " Restore the saved value of 'cpo' + let &cpo = s:save_cpo + unlet s:save_cpo +< +============================================================================== +vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl: diff --git a/vim-plugins/bundle/tabular/doc/tags b/vim-plugins/bundle/tabular/doc/tags new file mode 100644 index 0000000..9040110 --- /dev/null +++ b/vim-plugins/bundle/tabular/doc/tags @@ -0,0 +1,8 @@ +:Tabularize Tabular.txt /*:Tabularize* +Tabular.txt Tabular.txt /*Tabular.txt* +tabular Tabular.txt /*tabular* +tabular-intro Tabular.txt /*tabular-intro* +tabular-scripting Tabular.txt /*tabular-scripting* +tabular-toc Tabular.txt /*tabular-toc* +tabular-walkthrough Tabular.txt /*tabular-walkthrough* +tabular.vim Tabular.txt /*tabular.vim* diff --git a/vim-plugins/bundle/tabular/plugin/Tabular.vim b/vim-plugins/bundle/tabular/plugin/Tabular.vim new file mode 100644 index 0000000..e73329a --- /dev/null +++ b/vim-plugins/bundle/tabular/plugin/Tabular.vim @@ -0,0 +1,346 @@ +" Tabular: Align columnar data using regex-designated column boundaries +" Maintainer: Matthew Wozniski (godlygeek@gmail.com) +" Date: Thu, 03 May 2012 20:49:32 -0400 +" Version: 1.0 +" +" Long Description: +" Sometimes, it's useful to line up text. Naturally, it's nicer to have the +" computer do this for you, since aligning things by hand quickly becomes +" unpleasant. While there are other plugins for aligning text, the ones I've +" tried are either impossibly difficult to understand and use, or too simplistic +" to handle complicated tasks. This plugin aims to make the easy things easy +" and the hard things possible, without providing an unnecessarily obtuse +" interface. It's still a work in progress, and criticisms are welcome. +" +" License: +" Copyright (c) 2012, Matthew J. Wozniski +" All rights reserved. +" +" Redistribution and use in source and binary forms, with or without +" modification, are permitted provided that the following conditions are met: +" * Redistributions of source code must retain the above copyright notice, +" this list of conditions and the following disclaimer. +" * Redistributions in binary form must reproduce the above copyright +" notice, this list of conditions and the following disclaimer in the +" documentation and/or other materials provided with the distribution. +" * The names of the contributors may not be used to endorse or promote +" products derived from this software without specific prior written +" permission. +" +" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS +" OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN +" NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, +" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +" OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +" NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +" EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +" Abort if running in vi-compatible mode or the user doesn't want us. +if &cp || exists('g:tabular_loaded') + if &cp && &verbose + echo "Not loading Tabular in compatible mode." + endif + finish +endif + +let g:tabular_loaded = 1 + +" Stupid vimscript crap {{{1 +let s:savecpo = &cpo +set cpo&vim + +" Private Things {{{1 + +" Dictionary of command name to command +let s:TabularCommands = {} + +" Generate tab completion list for :Tabularize {{{2 +" Return a list of commands that match the command line typed so far. +" NOTE: Tries to handle commands with spaces in the name, but Vim doesn't seem +" to handle that terribly well... maybe I should give up on that. +function! s:CompleteTabularizeCommand(argstart, cmdline, cursorpos) + let names = keys(s:TabularCommands) + if exists("b:TabularCommands") + let names += keys(b:TabularCommands) + endif + + let cmdstart = substitute(a:cmdline, '^\s*\S\+\s*', '', '') + + return filter(names, 'v:val =~# ''^\V'' . escape(cmdstart, ''\'')') +endfunction + +" Choose the proper command map from the given command line {{{2 +" Returns [ command map, command line with leading removed ] +function! s:ChooseCommandMap(commandline) + let map = s:TabularCommands + let cmd = a:commandline + + if cmd =~# '^\s\+' + if !exists('b:TabularCommands') + let b:TabularCommands = {} + endif + let map = b:TabularCommands + let cmd = substitute(cmd, '^\s\+', '', '') + endif + + return [ map, cmd ] +endfunction + +" Parse '/pattern/format' into separate pattern and format parts. {{{2 +" If parsing fails, return [ '', '' ] +function! s:ParsePattern(string) + if a:string[0] != '/' + return ['',''] + endif + + let pat = '\\\@ 0)] =~ '^\s*$' + throw "Empty element" + endif + + if end == -1 + let rv = [ a:string ] + else + let rv = [ a:string[0 : end-1] ] + s:SplitCommands(a:string[end+1 : -1]) + endif + + return rv +endfunction + +" Public Things {{{1 + +" Command associating a command name with a simple pattern command {{{2 +" AddTabularPattern[!] [] name /pattern[/format] +" +" If is provided, the command will only be available in the current +" buffer, and will be used instead of any global command with the same name. +" +" If a command with the same name and scope already exists, it is an error, +" unless the ! is provided, in which case the existing command will be +" replaced. +" +" pattern is a regex describing the delimiter to be used. +" +" format describes the format pattern to be used. The default will be used if +" none is provided. +com! -nargs=+ -bang AddTabularPattern + \ call AddTabularPattern(, 0) + +function! AddTabularPattern(command, force) + try + let [ commandmap, rest ] = s:ChooseCommandMap(a:command) + + let name = matchstr(rest, '.\{-}\ze\s*/') + let pattern = substitute(rest, '.\{-}\s*\ze/', '', '') + + let [ pattern, format ] = s:ParsePattern(pattern) + + if empty(name) || empty(pattern) + throw "Invalid arguments!" + endif + + if !a:force && has_key(commandmap, name) + throw string(name) . " is already defined, use ! to overwrite." + endif + + let command = "tabular#TabularizeStrings(a:lines, " . string(pattern) + + if !empty(format) + let command .= ", " . string(format) + endif + + let command .= ")" + + let commandmap[name] = { 'pattern' : pattern, 'commands' : [ command ] } + catch + echohl ErrorMsg + echomsg "AddTabularPattern: " . v:exception + echohl None + endtry +endfunction + +" Command associating a command name with a pipeline of functions {{{2 +" AddTabularPipeline[!] [] name /pattern/ func [ | func2 [ | func3 ] ] +" +" If is provided, the command will only be available in the current +" buffer, and will be used instead of any global command with the same name. +" +" If a command with the same name and scope already exists, it is an error, +" unless the ! is provided, in which case the existing command will be +" replaced. +" +" pattern is a regex that will be used to determine which lines will be +" filtered. If the cursor line doesn't match the pattern, using the command +" will be a no-op, otherwise the cursor and all contiguous lines matching the +" pattern will be filtered. +" +" Each 'func' argument represents a function to be called. This function +" will have access to a:lines, a List containing one String per line being +" filtered. +com! -nargs=+ -bang AddTabularPipeline + \ call AddTabularPipeline(, 0) + +function! AddTabularPipeline(command, force) + try + let [ commandmap, rest ] = s:ChooseCommandMap(a:command) + + let name = matchstr(rest, '.\{-}\ze\s*/') + let pattern = substitute(rest, '.\{-}\s*\ze/', '', '') + + let commands = matchstr(pattern, '^/.\{-}\\\@CompleteTabularizeCommand + \ Tabularize ,call Tabularize() + +function! Tabularize(command, ...) range + let piperange_opt = {} + if a:0 + let piperange_opt = a:1 + endif + + if empty(a:command) + if !exists("s:last_tabularize_command") + echohl ErrorMsg + echomsg "Tabularize hasn't been called yet; no pattern/command to reuse!" + echohl None + return + endif + else + let s:last_tabularize_command = a:command + endif + + let command = s:last_tabularize_command + + let range = a:firstline . ',' . a:lastline + + try + let [ pattern, format ] = s:ParsePattern(command) + + if !empty(pattern) + let cmd = "tabular#TabularizeStrings(a:lines, " . string(pattern) + + if !empty(format) + let cmd .= "," . string(format) + endif + + let cmd .= ")" + + exe range . 'call tabular#PipeRangeWithOptions(pattern, [ cmd ], ' + \ . 'piperange_opt)' + else + if exists('b:TabularCommands') && has_key(b:TabularCommands, command) + let usercmd = b:TabularCommands[command] + elseif has_key(s:TabularCommands, command) + let usercmd = s:TabularCommands[command] + else + throw "Unrecognized command " . string(command) + endif + + exe range . 'call tabular#PipeRangeWithOptions(usercmd["pattern"], ' + \ . 'usercmd["commands"], piperange_opt)' + endif + catch + echohl ErrorMsg + echomsg "Tabularize: " . v:exception + echohl None + return + endtry +endfunction + +" GTabularize /pattern[/format] {{{2 +" GTabularize name +" +" Align text on only matching lines, either using the given pattern, or the +" command associated with the given name. Mnemonically, this is similar to +" the :global command, which takes some action on all rows matching a pattern +" in a range. This command is different from normal :Tabularize in 3 ways: +" 1) If a line in the range does not match the pattern, it will be left +" unchanged, and not in any way affect the outcome of other lines in the +" range (at least, normally - but Pipelines can and will still look at +" non-matching rows unless they are specifically written to be aware of +" tabular#DoGTabularize() and handle it appropriately). +" 2) No automatic range determination - :Tabularize automatically expands +" a single-line range (or a call with no range) to include all adjacent +" matching lines. That behavior does not make sense for this command. +" 3) If called without a range, it will act on all lines in the buffer (like +" :global) rather than only a single line +com! -nargs=* -range=% -complete=customlist,CompleteTabularizeCommand + \ GTabularize , + \ call Tabularize(, { 'mode': 'GTabularize' } ) + +" Stupid vimscript crap, part 2 {{{1 +let &cpo = s:savecpo +unlet s:savecpo + +" vim:set sw=2 sts=2 fdm=marker: diff --git a/vim-plugins/bundle/targets.vim/doc/tags b/vim-plugins/bundle/targets.vim/doc/tags new file mode 100644 index 0000000..f7c2707 --- /dev/null +++ b/vim-plugins/bundle/targets.vim/doc/tags @@ -0,0 +1,528 @@ +A# targets.txt /*A#* +A$ targets.txt /*A$* +A& targets.txt /*A&* +A' targets.txt /*A'* +A( targets.txt /*A(* +A) targets.txt /*A)* +A+ targets.txt /*A+* +A, targets.txt /*A,* +A- targets.txt /*A-* +A. targets.txt /*A.* +A/ targets.txt /*A\/* +A: targets.txt /*A:* +A; targets.txt /*A;* +A< targets.txt /*A<* +A= targets.txt /*A=* +A> targets.txt /*A>* +AB targets.txt /*AB* +AL# targets.txt /*AL#* +AL$ targets.txt /*AL$* +AL& targets.txt /*AL&* +AL+ targets.txt /*AL+* +AL, targets.txt /*AL,* +AL- targets.txt /*AL-* +AL. targets.txt /*AL.* +AL/ targets.txt /*AL\/* +AL: targets.txt /*AL:* +AL; targets.txt /*AL;* +AL= targets.txt /*AL=* +AL\ targets.txt /*AL\\* +AL_ targets.txt /*AL_* +ALstar targets.txt /*ALstar* +AL~ targets.txt /*AL~* +AN# targets.txt /*AN#* +AN$ targets.txt /*AN$* +AN& targets.txt /*AN&* +AN+ targets.txt /*AN+* +AN, targets.txt /*AN,* +AN- targets.txt /*AN-* +AN. targets.txt /*AN.* +AN/ targets.txt /*AN\/* +AN: targets.txt /*AN:* +AN; targets.txt /*AN;* +AN= targets.txt /*AN=* +AN\ targets.txt /*AN\\* +AN_ targets.txt /*AN_* +ANstar targets.txt /*ANstar* +AN~ targets.txt /*AN~* +A[ targets.txt /*A[* +A\ targets.txt /*A\\* +A] targets.txt /*A]* +A_ targets.txt /*A_* +A` targets.txt /*A`* +Aa targets.txt /*Aa* +Ab targets.txt /*Ab* +Al# targets.txt /*Al#* +Al$ targets.txt /*Al$* +Al& targets.txt /*Al&* +Al( targets.txt /*Al(* +Al) targets.txt /*Al)* +Al+ targets.txt /*Al+* +Al, targets.txt /*Al,* +Al- targets.txt /*Al-* +Al. targets.txt /*Al.* +Al/ targets.txt /*Al\/* +Al: targets.txt /*Al:* +Al; targets.txt /*Al;* +Al< targets.txt /*Al<* +Al= targets.txt /*Al=* +Al> targets.txt /*Al>* +AlB targets.txt /*AlB* +Al[ targets.txt /*Al[* +Al\ targets.txt /*Al\\* +Al] targets.txt /*Al]* +Al_ targets.txt /*Al_* +Ala targets.txt /*Ala* +Alb targets.txt /*Alb* +Alstar targets.txt /*Alstar* +Alt targets.txt /*Alt* +Al{ targets.txt /*Al{* +Al} targets.txt /*Al}* +Al~ targets.txt /*Al~* +An# targets.txt /*An#* +An$ targets.txt /*An$* +An& targets.txt /*An&* +An( targets.txt /*An(* +An) targets.txt /*An)* +An+ targets.txt /*An+* +An, targets.txt /*An,* +An- targets.txt /*An-* +An. targets.txt /*An.* +An/ targets.txt /*An\/* +An: targets.txt /*An:* +An; targets.txt /*An;* +An< targets.txt /*An<* +An= targets.txt /*An=* +An> targets.txt /*An>* +AnB targets.txt /*AnB* +An[ targets.txt /*An[* +An\ targets.txt /*An\\* +An] targets.txt /*An]* +An_ targets.txt /*An_* +Ana targets.txt /*Ana* +Anb targets.txt /*Anb* +Anstar targets.txt /*Anstar* +Ant targets.txt /*Ant* +An{ targets.txt /*An{* +An} targets.txt /*An}* +An~ targets.txt /*An~* +Aquote targets.txt /*Aquote* +Astar targets.txt /*Astar* +At targets.txt /*At* +A{ targets.txt /*A{* +A} targets.txt /*A}* +A~ targets.txt /*A~* +I# targets.txt /*I#* +I$ targets.txt /*I$* +I& targets.txt /*I&* +I' targets.txt /*I'* +I( targets.txt /*I(* +I) targets.txt /*I)* +I+ targets.txt /*I+* +I, targets.txt /*I,* +I- targets.txt /*I-* +I. targets.txt /*I.* +I/ targets.txt /*I\/* +I: targets.txt /*I:* +I; targets.txt /*I;* +I< targets.txt /*I<* +I= targets.txt /*I=* +I> targets.txt /*I>* +IB targets.txt /*IB* +IL# targets.txt /*IL#* +IL$ targets.txt /*IL$* +IL& targets.txt /*IL&* +IL' targets.txt /*IL'* +IL+ targets.txt /*IL+* +IL, targets.txt /*IL,* +IL- targets.txt /*IL-* +IL. targets.txt /*IL.* +IL/ targets.txt /*IL\/* +IL: targets.txt /*IL:* +IL; targets.txt /*IL;* +IL= targets.txt /*IL=* +IL\ targets.txt /*IL\\* +IL_ targets.txt /*IL_* +IL` targets.txt /*IL`* +ILquote targets.txt /*ILquote* +ILstar targets.txt /*ILstar* +IL~ targets.txt /*IL~* +IN# targets.txt /*IN#* +IN$ targets.txt /*IN$* +IN& targets.txt /*IN&* +IN' targets.txt /*IN'* +IN+ targets.txt /*IN+* +IN, targets.txt /*IN,* +IN- targets.txt /*IN-* +IN. targets.txt /*IN.* +IN/ targets.txt /*IN\/* +IN: targets.txt /*IN:* +IN; targets.txt /*IN;* +IN= targets.txt /*IN=* +IN\ targets.txt /*IN\\* +IN_ targets.txt /*IN_* +IN` targets.txt /*IN`* +INquote targets.txt /*INquote* +INstar targets.txt /*INstar* +IN~ targets.txt /*IN~* +I[ targets.txt /*I[* +I\ targets.txt /*I\\* +I] targets.txt /*I]* +I_ targets.txt /*I_* +I` targets.txt /*I`* +Ia targets.txt /*Ia* +Ib targets.txt /*Ib* +Il# targets.txt /*Il#* +Il$ targets.txt /*Il$* +Il& targets.txt /*Il&* +Il' targets.txt /*Il'* +Il( targets.txt /*Il(* +Il) targets.txt /*Il)* +Il+ targets.txt /*Il+* +Il, targets.txt /*Il,* +Il- targets.txt /*Il-* +Il. targets.txt /*Il.* +Il/ targets.txt /*Il\/* +Il: targets.txt /*Il:* +Il; targets.txt /*Il;* +Il< targets.txt /*Il<* +Il= targets.txt /*Il=* +Il> targets.txt /*Il>* +IlB targets.txt /*IlB* +Il[ targets.txt /*Il[* +Il\ targets.txt /*Il\\* +Il] targets.txt /*Il]* +Il_ targets.txt /*Il_* +Il` targets.txt /*Il`* +Ila targets.txt /*Ila* +Ilb targets.txt /*Ilb* +Ilquote targets.txt /*Ilquote* +Ilstar targets.txt /*Ilstar* +Ilt targets.txt /*Ilt* +Il{ targets.txt /*Il{* +Il} targets.txt /*Il}* +Il~ targets.txt /*Il~* +In# targets.txt /*In#* +In$ targets.txt /*In$* +In& targets.txt /*In&* +In' targets.txt /*In'* +In( targets.txt /*In(* +In) targets.txt /*In)* +In+ targets.txt /*In+* +In, targets.txt /*In,* +In- targets.txt /*In-* +In. targets.txt /*In.* +In/ targets.txt /*In\/* +In: targets.txt /*In:* +In; targets.txt /*In;* +In< targets.txt /*In<* +In= targets.txt /*In=* +In> targets.txt /*In>* +InB targets.txt /*InB* +In[ targets.txt /*In[* +In\ targets.txt /*In\\* +In] targets.txt /*In]* +In_ targets.txt /*In_* +In` targets.txt /*In`* +Ina targets.txt /*Ina* +Inb targets.txt /*Inb* +Inquote targets.txt /*Inquote* +Instar targets.txt /*Instar* +Int targets.txt /*Int* +In{ targets.txt /*In{* +In} targets.txt /*In}* +In~ targets.txt /*In~* +Iquote targets.txt /*Iquote* +Istar targets.txt /*Istar* +It targets.txt /*It* +I{ targets.txt /*I{* +I} targets.txt /*I}* +I~ targets.txt /*I~* +a# targets.txt /*a#* +a$ targets.txt /*a$* +a& targets.txt /*a&* +a'_t targets.txt /*a'_t* +a(_t targets.txt /*a(_t* +a)_t targets.txt /*a)_t* +a+ targets.txt /*a+* +a, targets.txt /*a,* +a- targets.txt /*a-* +a. targets.txt /*a.* +a/ targets.txt /*a\/* +a: targets.txt /*a:* +a; targets.txt /*a;* +a<_t targets.txt /*a<_t* +a= targets.txt /*a=* +a>_t targets.txt /*a>_t* +aB_t targets.txt /*aB_t* +aL# targets.txt /*aL#* +aL$ targets.txt /*aL$* +aL& targets.txt /*aL&* +aL' targets.txt /*aL'* +aL+ targets.txt /*aL+* +aL, targets.txt /*aL,* +aL- targets.txt /*aL-* +aL. targets.txt /*aL.* +aL/ targets.txt /*aL\/* +aL: targets.txt /*aL:* +aL; targets.txt /*aL;* +aL= targets.txt /*aL=* +aL\ targets.txt /*aL\\* +aL_ targets.txt /*aL_* +aL` targets.txt /*aL`* +aLquote targets.txt /*aLquote* +aLstar targets.txt /*aLstar* +aL~ targets.txt /*aL~* +aN# targets.txt /*aN#* +aN$ targets.txt /*aN$* +aN& targets.txt /*aN&* +aN' targets.txt /*aN'* +aN+ targets.txt /*aN+* +aN, targets.txt /*aN,* +aN- targets.txt /*aN-* +aN. targets.txt /*aN.* +aN/ targets.txt /*aN\/* +aN: targets.txt /*aN:* +aN; targets.txt /*aN;* +aN= targets.txt /*aN=* +aN\ targets.txt /*aN\\* +aN_ targets.txt /*aN_* +aN` targets.txt /*aN`* +aNquote targets.txt /*aNquote* +aNstar targets.txt /*aNstar* +aN~ targets.txt /*aN~* +a[_t targets.txt /*a[_t* +a\ targets.txt /*a\\* +a]_t targets.txt /*a]_t* +a_ targets.txt /*a_* +a`_t targets.txt /*a`_t* +aa targets.txt /*aa* +ab_t targets.txt /*ab_t* +al# targets.txt /*al#* +al$ targets.txt /*al$* +al& targets.txt /*al&* +al' targets.txt /*al'* +al( targets.txt /*al(* +al) targets.txt /*al)* +al+ targets.txt /*al+* +al, targets.txt /*al,* +al- targets.txt /*al-* +al. targets.txt /*al.* +al/ targets.txt /*al\/* +al: targets.txt /*al:* +al; targets.txt /*al;* +al< targets.txt /*al<* +al= targets.txt /*al=* +al> targets.txt /*al>* +alB targets.txt /*alB* +al[ targets.txt /*al[* +al\ targets.txt /*al\\* +al] targets.txt /*al]* +al_ targets.txt /*al_* +al` targets.txt /*al`* +ala targets.txt /*ala* +alb targets.txt /*alb* +alquote targets.txt /*alquote* +alstar targets.txt /*alstar* +alt targets.txt /*alt* +al{ targets.txt /*al{* +al} targets.txt /*al}* +al~ targets.txt /*al~* +an# targets.txt /*an#* +an$ targets.txt /*an$* +an& targets.txt /*an&* +an' targets.txt /*an'* +an( targets.txt /*an(* +an) targets.txt /*an)* +an+ targets.txt /*an+* +an, targets.txt /*an,* +an- targets.txt /*an-* +an. targets.txt /*an.* +an/ targets.txt /*an\/* +an: targets.txt /*an:* +an; targets.txt /*an;* +an< targets.txt /*an<* +an= targets.txt /*an=* +an> targets.txt /*an>* +anB targets.txt /*anB* +an[ targets.txt /*an[* +an\ targets.txt /*an\\* +an] targets.txt /*an]* +an_ targets.txt /*an_* +an` targets.txt /*an`* +ana targets.txt /*ana* +anb targets.txt /*anb* +anquote targets.txt /*anquote* +anstar targets.txt /*anstar* +ant targets.txt /*ant* +an{ targets.txt /*an{* +an} targets.txt /*an}* +an~ targets.txt /*an~* +aquote_t targets.txt /*aquote_t* +astar targets.txt /*astar* +at_t targets.txt /*at_t* +a{_t targets.txt /*a{_t* +a}_t targets.txt /*a}_t* +a~ targets.txt /*a~* +g:targets_aiAI targets.txt /*g:targets_aiAI* +g:targets_argClosing targets.txt /*g:targets_argClosing* +g:targets_argOpening targets.txt /*g:targets_argOpening* +g:targets_argSeparator targets.txt /*g:targets_argSeparator* +g:targets_argTrigger targets.txt /*g:targets_argTrigger* +g:targets_jumpRanges targets.txt /*g:targets_jumpRanges* +g:targets_nlNL targets.txt /*g:targets_nlNL* +g:targets_pairs targets.txt /*g:targets_pairs* +g:targets_quotes targets.txt /*g:targets_quotes* +g:targets_seekRanges targets.txt /*g:targets_seekRanges* +g:targets_separators targets.txt /*g:targets_separators* +g:targets_tagTrigger targets.txt /*g:targets_tagTrigger* +i# targets.txt /*i#* +i$ targets.txt /*i$* +i& targets.txt /*i&* +i'_t targets.txt /*i'_t* +i(_t targets.txt /*i(_t* +i)_t targets.txt /*i)_t* +i+ targets.txt /*i+* +i, targets.txt /*i,* +i- targets.txt /*i-* +i. targets.txt /*i.* +i/ targets.txt /*i\/* +i: targets.txt /*i:* +i; targets.txt /*i;* +i<_t targets.txt /*i<_t* +i= targets.txt /*i=* +i>_t targets.txt /*i>_t* +iB_t targets.txt /*iB_t* +iL# targets.txt /*iL#* +iL$ targets.txt /*iL$* +iL& targets.txt /*iL&* +iL' targets.txt /*iL'* +iL+ targets.txt /*iL+* +iL, targets.txt /*iL,* +iL- targets.txt /*iL-* +iL. targets.txt /*iL.* +iL/ targets.txt /*iL\/* +iL: targets.txt /*iL:* +iL; targets.txt /*iL;* +iL= targets.txt /*iL=* +iL\ targets.txt /*iL\\* +iL_ targets.txt /*iL_* +iL` targets.txt /*iL`* +iLquote targets.txt /*iLquote* +iLstar targets.txt /*iLstar* +iL~ targets.txt /*iL~* +iN# targets.txt /*iN#* +iN$ targets.txt /*iN$* +iN& targets.txt /*iN&* +iN' targets.txt /*iN'* +iN+ targets.txt /*iN+* +iN, targets.txt /*iN,* +iN- targets.txt /*iN-* +iN. targets.txt /*iN.* +iN/ targets.txt /*iN\/* +iN: targets.txt /*iN:* +iN; targets.txt /*iN;* +iN= targets.txt /*iN=* +iN\ targets.txt /*iN\\* +iN_ targets.txt /*iN_* +iN` targets.txt /*iN`* +iNquote targets.txt /*iNquote* +iNstar targets.txt /*iNstar* +iN~ targets.txt /*iN~* +i[_t targets.txt /*i[_t* +i\ targets.txt /*i\\* +i]_t targets.txt /*i]_t* +i_ targets.txt /*i_* +i`_t targets.txt /*i`_t* +ia targets.txt /*ia* +ib_t targets.txt /*ib_t* +il# targets.txt /*il#* +il$ targets.txt /*il$* +il& targets.txt /*il&* +il' targets.txt /*il'* +il( targets.txt /*il(* +il) targets.txt /*il)* +il+ targets.txt /*il+* +il, targets.txt /*il,* +il- targets.txt /*il-* +il. targets.txt /*il.* +il/ targets.txt /*il\/* +il: targets.txt /*il:* +il; targets.txt /*il;* +il< targets.txt /*il<* +il= targets.txt /*il=* +il> targets.txt /*il>* +ilB targets.txt /*ilB* +il[ targets.txt /*il[* +il\ targets.txt /*il\\* +il] targets.txt /*il]* +il_ targets.txt /*il_* +il` targets.txt /*il`* +ila targets.txt /*ila* +ilb targets.txt /*ilb* +ilquote targets.txt /*ilquote* +ilstar targets.txt /*ilstar* +ilt targets.txt /*ilt* +il{ targets.txt /*il{* +il} targets.txt /*il}* +il~ targets.txt /*il~* +in# targets.txt /*in#* +in$ targets.txt /*in$* +in& targets.txt /*in&* +in' targets.txt /*in'* +in( targets.txt /*in(* +in) targets.txt /*in)* +in+ targets.txt /*in+* +in, targets.txt /*in,* +in- targets.txt /*in-* +in. targets.txt /*in.* +in/ targets.txt /*in\/* +in: targets.txt /*in:* +in; targets.txt /*in;* +in< targets.txt /*in<* +in= targets.txt /*in=* +in> targets.txt /*in>* +inB targets.txt /*inB* +in[ targets.txt /*in[* +in\ targets.txt /*in\\* +in] targets.txt /*in]* +in_ targets.txt /*in_* +in` targets.txt /*in`* +ina targets.txt /*ina* +inb targets.txt /*inb* +inquote targets.txt /*inquote* +instar targets.txt /*instar* +int targets.txt /*int* +in{ targets.txt /*in{* +in} targets.txt /*in}* +in~ targets.txt /*in~* +iquote_t targets.txt /*iquote_t* +istar targets.txt /*istar* +it_t targets.txt /*it_t* +i{_t targets.txt /*i{_t* +i}_t targets.txt /*i}_t* +i~ targets.txt /*i~* +targets-argument-chart targets.txt /*targets-argument-chart* +targets-argument-seek targets.txt /*targets-argument-seek* +targets-argument-text-objects targets.txt /*targets-argument-text-objects* +targets-examples targets.txt /*targets-examples* +targets-introduction targets.txt /*targets-introduction* +targets-issues targets.txt /*targets-issues* +targets-next-last-argument targets.txt /*targets-next-last-argument* +targets-next-last-pair targets.txt /*targets-next-last-pair* +targets-next-last-quote targets.txt /*targets-next-last-quote* +targets-next-last-separator targets.txt /*targets-next-last-separator* +targets-notes targets.txt /*targets-notes* +targets-overview targets.txt /*targets-overview* +targets-pair-charts targets.txt /*targets-pair-charts* +targets-pair-seek targets.txt /*targets-pair-seek* +targets-pair-text-objects targets.txt /*targets-pair-text-objects* +targets-quote-chart targets.txt /*targets-quote-chart* +targets-quote-seek targets.txt /*targets-quote-seek* +targets-quote-text-objects targets.txt /*targets-quote-text-objects* +targets-separator-chart targets.txt /*targets-separator-chart* +targets-separator-seek targets.txt /*targets-separator-seek* +targets-separator-text-objects targets.txt /*targets-separator-text-objects* +targets-settings targets.txt /*targets-settings* +targets-todos targets.txt /*targets-todos* +targets.txt targets.txt /*targets.txt* diff --git a/vim-plugins/bundle/vim-indent-object/doc/tags b/vim-plugins/bundle/vim-indent-object/doc/tags new file mode 100644 index 0000000..2216eaa --- /dev/null +++ b/vim-plugins/bundle/vim-indent-object/doc/tags @@ -0,0 +1,9 @@ +aI indent-object.txt /*aI* +ai indent-object.txt /*ai* +iI indent-object.txt /*iI* +ii indent-object.txt /*ii* +indent-object.txt indent-object.txt /*indent-object.txt* +indtobj-about indent-object.txt /*indtobj-about* +indtobj-blanklines indent-object.txt /*indtobj-blanklines* +indtobj-introduction indent-object.txt /*indtobj-introduction* +indtobj-objects indent-object.txt /*indtobj-objects* diff --git a/vim-plugins/bundle/vim-lion/doc/tags b/vim-plugins/bundle/vim-lion/doc/tags new file mode 100644 index 0000000..484880a --- /dev/null +++ b/vim-plugins/bundle/vim-lion/doc/tags @@ -0,0 +1,12 @@ +gL lion.txt /*gL* +gl lion.txt /*gl* +lion lion.txt /*lion* +lion-configuration lion.txt /*lion-configuration* +lion-examples lion.txt /*lion-examples* +lion-issues lion.txt /*lion-issues* +lion-left-align lion.txt /*lion-left-align* +lion-mappings lion.txt /*lion-mappings* +lion-my-love lion.txt /*lion-my-love* +lion-right-align lion.txt /*lion-right-align* +lion-todo lion.txt /*lion-todo* +lion.txt lion.txt /*lion.txt* diff --git a/vim-plugins/bundle/vim-markdown/doc/tags b/vim-plugins/bundle/vim-markdown/doc/tags new file mode 100644 index 0000000..c9a4fc2 --- /dev/null +++ b/vim-plugins/bundle/vim-markdown/doc/tags @@ -0,0 +1,41 @@ +:HeaderDecrease vim-markdown.txt /*:HeaderDecrease* +:HeaderIncrease vim-markdown.txt /*:HeaderIncrease* +:SetexToAtx vim-markdown.txt /*:SetexToAtx* +:TableFormat vim-markdown.txt /*:TableFormat* +:Toc vim-markdown.txt /*:Toc* +:Toch vim-markdown.txt /*:Toch* +:Toct vim-markdown.txt /*:Toct* +:Tocv vim-markdown.txt /*:Tocv* +vim-markdown vim-markdown.txt /*vim-markdown* +vim-markdown-[[ vim-markdown.txt /*vim-markdown-[[* +vim-markdown-[] vim-markdown.txt /*vim-markdown-[]* +vim-markdown-][ vim-markdown.txt /*vim-markdown-][* +vim-markdown-]] vim-markdown.txt /*vim-markdown-]]* +vim-markdown-]c vim-markdown.txt /*vim-markdown-]c* +vim-markdown-]u vim-markdown.txt /*vim-markdown-]u* +vim-markdown-adjust-new-list-item-indent vim-markdown.txt /*vim-markdown-adjust-new-list-item-indent* +vim-markdown-auto-write-when-following-link vim-markdown.txt /*vim-markdown-auto-write-when-following-link* +vim-markdown-change-fold-style vim-markdown.txt /*vim-markdown-change-fold-style* +vim-markdown-commands vim-markdown.txt /*vim-markdown-commands* +vim-markdown-credits vim-markdown.txt /*vim-markdown-credits* +vim-markdown-disable-default-key-mappings vim-markdown.txt /*vim-markdown-disable-default-key-mappings* +vim-markdown-disable-folding vim-markdown.txt /*vim-markdown-disable-folding* +vim-markdown-do-not-require-.md-extensions-for-markdown-links vim-markdown.txt /*vim-markdown-do-not-require-.md-extensions-for-markdown-links* +vim-markdown-enable-toc-window-auto-fit vim-markdown.txt /*vim-markdown-enable-toc-window-auto-fit* +vim-markdown-fenced-code-block-languages vim-markdown.txt /*vim-markdown-fenced-code-block-languages* +vim-markdown-ge vim-markdown.txt /*vim-markdown-ge* +vim-markdown-gx vim-markdown.txt /*vim-markdown-gx* +vim-markdown-installation vim-markdown.txt /*vim-markdown-installation* +vim-markdown-introduction vim-markdown.txt /*vim-markdown-introduction* +vim-markdown-json-front-matter vim-markdown.txt /*vim-markdown-json-front-matter* +vim-markdown-latex-math vim-markdown.txt /*vim-markdown-latex-math* +vim-markdown-license vim-markdown.txt /*vim-markdown-license* +vim-markdown-mappings vim-markdown.txt /*vim-markdown-mappings* +vim-markdown-options vim-markdown.txt /*vim-markdown-options* +vim-markdown-references vim-markdown.txt /*vim-markdown-references* +vim-markdown-set-header-folding-level vim-markdown.txt /*vim-markdown-set-header-folding-level* +vim-markdown-syntax-concealing vim-markdown.txt /*vim-markdown-syntax-concealing* +vim-markdown-syntax-extensions vim-markdown.txt /*vim-markdown-syntax-extensions* +vim-markdown-text-emphasis-restriction-to-single-lines vim-markdown.txt /*vim-markdown-text-emphasis-restriction-to-single-lines* +vim-markdown-toml-front-matter vim-markdown.txt /*vim-markdown-toml-front-matter* +vim-markdown-yaml-front-matter vim-markdown.txt /*vim-markdown-yaml-front-matter* diff --git a/vim-plugins/bundle/vim-virtualenv/doc/tags b/vim-plugins/bundle/vim-virtualenv/doc/tags new file mode 100644 index 0000000..2eb7151 --- /dev/null +++ b/vim-plugins/bundle/vim-virtualenv/doc/tags @@ -0,0 +1,13 @@ +:VirtualEnvActivate virtualenv.txt /*:VirtualEnvActivate* +:VirtualEnvDeactivate virtualenv.txt /*:VirtualEnvDeactivate* +:VirtualEnvList virtualenv.txt /*:VirtualEnvList* +g:virtualenv_auto_activate virtualenv.txt /*g:virtualenv_auto_activate* +g:virtualenv_directory virtualenv.txt /*g:virtualenv_directory* +g:virtualenv_loaded virtualenv.txt /*g:virtualenv_loaded* +g:virtualenv_stl_format virtualenv.txt /*g:virtualenv_stl_format* +virtualenv virtualenv.txt /*virtualenv* +virtualenv-author virtualenv.txt /*virtualenv-author* +virtualenv-commands virtualenv.txt /*virtualenv-commands* +virtualenv-configuration virtualenv.txt /*virtualenv-configuration* +virtualenv.txt virtualenv.txt /*virtualenv.txt* +virtualenv.vim virtualenv.txt /*virtualenv.vim* diff --git a/vim-plugins/eclim/doc/tags b/vim-plugins/eclim/doc/tags new file mode 100644 index 0000000..7fceb23 --- /dev/null +++ b/vim-plugins/eclim/doc/tags @@ -0,0 +1,491 @@ +1.0.0 archive/changes.txt /*1.0.0* +1.1.0 archive/changes.txt /*1.1.0* +1.1.1 archive/changes.txt /*1.1.1* +1.1.2 archive/changes.txt /*1.1.2* +1.2.0 archive/changes.txt /*1.2.0* +1.2.1 archive/changes.txt /*1.2.1* +1.2.2 archive/changes.txt /*1.2.2* +1.2.3 archive/changes.txt /*1.2.3* +1.3.0 archive/changes.txt /*1.3.0* +1.3.1 archive/changes.txt /*1.3.1* +1.3.2 archive/changes.txt /*1.3.2* +1.3.3 archive/changes.txt /*1.3.3* +1.3.4 archive/changes.txt /*1.3.4* +1.3.5 archive/changes.txt /*1.3.5* +1.4.0 archive/changes.txt /*1.4.0* +1.4.1 archive/changes.txt /*1.4.1* +1.4.2 archive/changes.txt /*1.4.2* +1.4.3 archive/changes.txt /*1.4.3* +1.4.4 archive/changes.txt /*1.4.4* +1.4.5 archive/changes.txt /*1.4.5* +1.4.6 archive/changes.txt /*1.4.6* +1.4.7 archive/changes.txt /*1.4.7* +1.4.8 archive/changes.txt /*1.4.8* +1.4.9 archive/changes.txt /*1.4.9* +1.5.0 archive/changes.txt /*1.5.0* +1.5.1 archive/changes.txt /*1.5.1* +1.5.2 archive/changes.txt /*1.5.2* +1.5.3 archive/changes.txt /*1.5.3* +1.5.4 archive/changes.txt /*1.5.4* +1.5.5 archive/changes.txt /*1.5.5* +1.5.6 archive/changes.txt /*1.5.6* +1.5.7 archive/changes.txt /*1.5.7* +1.5.8 archive/changes.txt /*1.5.8* +1.6.0 archive/changes.txt /*1.6.0* +1.6.1 archive/changes.txt /*1.6.1* +1.6.2 archive/changes.txt /*1.6.2* +1.6.3 archive/changes.txt /*1.6.3* +1.7.0 archive/changes.txt /*1.7.0* +1.7.1 archive/changes.txt /*1.7.1* +1.7.10 archive/changes.txt /*1.7.10* +1.7.11 archive/changes.txt /*1.7.11* +1.7.12 archive/changes.txt /*1.7.12* +1.7.13 archive/changes.txt /*1.7.13* +1.7.14 changes.txt /*1.7.14* +1.7.16 changes.txt /*1.7.16* +1.7.17 changes.txt /*1.7.17* +1.7.18 changes.txt /*1.7.18* +1.7.19 changes.txt /*1.7.19* +1.7.2 archive/changes.txt /*1.7.2* +1.7.3 archive/changes.txt /*1.7.3* +1.7.4 archive/changes.txt /*1.7.4* +1.7.5 archive/changes.txt /*1.7.5* +1.7.6 archive/changes.txt /*1.7.6* +1.7.7 archive/changes.txt /*1.7.7* +1.7.8 archive/changes.txt /*1.7.8* +1.7.9 archive/changes.txt /*1.7.9* +2.2.0 archive/changes.txt /*2.2.0* +2.2.1 archive/changes.txt /*2.2.1* +2.2.2 archive/changes.txt /*2.2.2* +2.2.3 archive/changes.txt /*2.2.3* +2.2.4 archive/changes.txt /*2.2.4* +2.2.5 archive/changes.txt /*2.2.5* +2.2.6 changes.txt /*2.2.6* +2.2.7 changes.txt /*2.2.7* +2.3.0 changes.txt /*2.3.0* +2.3.1 changes.txt /*2.3.1* +2.3.2 changes.txt /*2.3.2* +2.3.3 changes.txt /*2.3.3* +2.3.4 changes.txt /*2.3.4* +2.4.0 changes.txt /*2.4.0* +2.4.1 changes.txt /*2.4.1* +2.5.0 changes.txt /*2.5.0* +2.6.0 changes.txt /*2.6.0* +2.7.0 changes.txt /*2.7.0* +404.html 404.txt /*404.html* +:AndroidReload vim/java/android.txt /*:AndroidReload* +:Ant vim/java/ant.txt /*:Ant* +:AntDoc vim/java/ant.txt /*:AntDoc* +:AntUserDoc vim/java/ant.txt /*:AntUserDoc* +:BrowserOpen vim/html/index.txt /*:BrowserOpen* +:Buffers vim/core/util.txt /*:Buffers* +:BuffersToggle vim/core/util.txt /*:BuffersToggle* +:CCallHierarchy vim/c/inspection.txt /*:CCallHierarchy* +:CProjectConfigs vim/c/project.txt /*:CProjectConfigs* +:CSearch vim/c/search.txt /*:CSearch* +:CSearchContext vim/c/search.txt /*:CSearchContext* +:Checkstyle vim/java/validate.txt /*:Checkstyle* +:DiffLastSaved vim/core/util.txt /*:DiffLastSaved* +:DjangoContextOpen vim/python/django.txt /*:DjangoContextOpen* +:DjangoFind vim/python/django.txt /*:DjangoFind* +:DjangoManage vim/python/django.txt /*:DjangoManage* +:DjangoTemplateOpen vim/python/django.txt /*:DjangoTemplateOpen* +:DjangoViewOpen vim/python/django.txt /*:DjangoViewOpen* +:DtdDefinition vim/xml/index.txt /*:DtdDefinition* +:EclimDisable vim/core/eclim.txt /*:EclimDisable* +:EclimEnable vim/core/eclim.txt /*:EclimEnable* +:EclimHelp vim/core/eclim.txt /*:EclimHelp* +:EclimHelpGrep vim/core/eclim.txt /*:EclimHelpGrep* +:History vim/core/history.txt /*:History* +:HistoryClear vim/core/history.txt /*:HistoryClear* +:HistoryDiffNext vim/core/history.txt /*:HistoryDiffNext* +:HistoryDiffPrev vim/core/history.txt /*:HistoryDiffPrev* +:IvyRepo vim/java/classpath.txt /*:IvyRepo* +:JUnit vim/java/unittests.txt /*:JUnit* +:JUnitFindTest vim/java/unittests.txt /*:JUnitFindTest* +:JUnitImpl vim/java/unittests.txt /*:JUnitImpl* +:JUnitResult vim/java/unittests.txt /*:JUnitResult* +:Java vim/java/java.txt /*:Java* +:JavaCallHierarchy vim/java/inspection.txt /*:JavaCallHierarchy* +:JavaClasspath vim/java/java.txt /*:JavaClasspath* +:JavaConstructor vim/java/methods.txt /*:JavaConstructor* +:JavaCorrect vim/java/validate.txt /*:JavaCorrect* +:JavaDebugBreakpointRemove vim/java/debug.txt /*:JavaDebugBreakpointRemove* +:JavaDebugBreakpointToggle vim/java/debug.txt /*:JavaDebugBreakpointToggle* +:JavaDebugBreakpointsList vim/java/debug.txt /*:JavaDebugBreakpointsList* +:JavaDebugStart vim/java/debug.txt /*:JavaDebugStart* +:JavaDebugStatus vim/java/debug.txt /*:JavaDebugStatus* +:JavaDebugStep vim/java/debug.txt /*:JavaDebugStep* +:JavaDebugStop vim/java/debug.txt /*:JavaDebugStop* +:JavaDebugThreadResume vim/java/debug.txt /*:JavaDebugThreadResume* +:JavaDebugThreadResumeAll vim/java/debug.txt /*:JavaDebugThreadResumeAll* +:JavaDebugThreadSuspendAll vim/java/debug.txt /*:JavaDebugThreadSuspendAll* +:JavaDelegate vim/java/methods.txt /*:JavaDelegate* +:JavaDocComment vim/java/javadoc.txt /*:JavaDocComment* +:JavaDocPreview vim/java/javadoc.txt /*:JavaDocPreview* +:JavaDocSearch vim/java/javadoc.txt /*:JavaDocSearch* +:JavaFormat vim/java/format.txt /*:JavaFormat* +:JavaGet vim/java/methods.txt /*:JavaGet* +:JavaGetSet vim/java/methods.txt /*:JavaGetSet* +:JavaHierarchy vim/java/inspection.txt /*:JavaHierarchy* +:JavaImpl vim/java/methods.txt /*:JavaImpl* +:JavaImport vim/java/import.txt /*:JavaImport* +:JavaImportOrganize vim/java/import.txt /*:JavaImportOrganize* +:JavaListInstalls vim/java/java.txt /*:JavaListInstalls* +:JavaMove vim/java/refactor.txt /*:JavaMove* +:JavaNew vim/java/types.txt /*:JavaNew* +:JavaRename vim/java/refactor.txt /*:JavaRename* +:JavaSearch vim/java/search.txt /*:JavaSearch* +:JavaSearchContext vim/java/search.txt /*:JavaSearchContext* +:JavaSet vim/java/methods.txt /*:JavaSet* +:Javadoc vim/java/javadoc.txt /*:Javadoc* +:Jps vim/java/java.txt /*:Jps* +:LocateFile vim/core/locate.txt /*:LocateFile* +:LocationListClear vim/core/util.txt /*:LocationListClear* +:Maven vim/java/maven.txt /*:Maven* +:MavenRepo vim/java/classpath.txt /*:MavenRepo* +:Mvn vim/java/maven.txt /*:Mvn* +:MvnRepo vim/java/classpath.txt /*:MvnRepo* +:NewJarEntry_java vim/java/classpath.txt /*:NewJarEntry_java* +:NewLibEntry_dltk vim/dltk/buildpath.txt /*:NewLibEntry_dltk* +:NewLibEntry_dltk_php vim/php/buildpath.txt /*:NewLibEntry_dltk_php* +:NewLibEntry_dltk_ruby vim/ruby/buildpath.txt /*:NewLibEntry_dltk_ruby* +:NewProjectEntry_dltk vim/dltk/buildpath.txt /*:NewProjectEntry_dltk* +:NewProjectEntry_dltk_php vim/php/buildpath.txt /*:NewProjectEntry_dltk_php* +:NewProjectEntry_dltk_ruby vim/ruby/buildpath.txt /*:NewProjectEntry_dltk_ruby* +:NewProjectEntry_java vim/java/classpath.txt /*:NewProjectEntry_java* +:NewSrcEntry_dltk vim/dltk/buildpath.txt /*:NewSrcEntry_dltk* +:NewSrcEntry_dltk_php vim/php/buildpath.txt /*:NewSrcEntry_dltk_php* +:NewSrcEntry_dltk_ruby vim/ruby/buildpath.txt /*:NewSrcEntry_dltk_ruby* +:NewSrcEntry_java vim/java/classpath.txt /*:NewSrcEntry_java* +:NewSrcEntry_pydev vim/python/path.txt /*:NewSrcEntry_pydev* +:NewVarEntry_java vim/java/classpath.txt /*:NewVarEntry_java* +:Only vim/core/util.txt /*:Only* +:OpenUrl vim/core/util.txt /*:OpenUrl* +:PhpSearch vim/php/search.txt /*:PhpSearch* +:PhpSearchContext vim/php/search.txt /*:PhpSearchContext* +:PingEclim vim/core/eclim.txt /*:PingEclim* +:ProjectBuild vim/core/project.txt /*:ProjectBuild* +:ProjectCD vim/core/project.txt /*:ProjectCD* +:ProjectClose vim/core/project.txt /*:ProjectClose* +:ProjectCreate vim/core/project.txt /*:ProjectCreate* +:ProjectDelete vim/core/project.txt /*:ProjectDelete* +:ProjectGrep vim/core/project.txt /*:ProjectGrep* +:ProjectGrepAdd vim/core/project.txt /*:ProjectGrepAdd* +:ProjectImport vim/core/project.txt /*:ProjectImport* +:ProjectImportDiscover vim/core/project.txt /*:ProjectImportDiscover* +:ProjectInfo vim/core/project.txt /*:ProjectInfo* +:ProjectLCD vim/core/project.txt /*:ProjectLCD* +:ProjectLGrep vim/core/project.txt /*:ProjectLGrep* +:ProjectLGrepAdd vim/core/project.txt /*:ProjectLGrepAdd* +:ProjectList vim/core/project.txt /*:ProjectList* +:ProjectMove vim/core/project.txt /*:ProjectMove* +:ProjectNatureAdd vim/core/project.txt /*:ProjectNatureAdd* +:ProjectNatureRemove vim/core/project.txt /*:ProjectNatureRemove* +:ProjectNatures vim/core/project.txt /*:ProjectNatures* +:ProjectOpen vim/core/project.txt /*:ProjectOpen* +:ProjectProblems vim/core/project.txt /*:ProjectProblems* +:ProjectRefresh vim/core/project.txt /*:ProjectRefresh* +:ProjectRefreshAll vim/core/project.txt /*:ProjectRefreshAll* +:ProjectRename vim/core/project.txt /*:ProjectRename* +:ProjectRun vim/core/project.txt /*:ProjectRun* +:ProjectRunList vim/core/project.txt /*:ProjectRunList* +:ProjectSettings vim/core/project.txt /*:ProjectSettings* +:ProjectTab vim/core/project.txt /*:ProjectTab* +:ProjectTodo vim/core/project.txt /*:ProjectTodo* +:ProjectTree vim/core/project.txt /*:ProjectTree* +:ProjectTreeToggle vim/core/project.txt /*:ProjectTreeToggle* +:ProjectsTree vim/core/project.txt /*:ProjectsTree* +:PythonInterpreter vim/python/path.txt /*:PythonInterpreter* +:PythonInterpreterAdd vim/python/path.txt /*:PythonInterpreterAdd* +:PythonInterpreterList vim/python/path.txt /*:PythonInterpreterList* +:PythonInterpreterRemove vim/python/path.txt /*:PythonInterpreterRemove* +:PythonSearch vim/python/search.txt /*:PythonSearch* +:PythonSearchContext vim/python/search.txt /*:PythonSearchContext* +:QuickFixClear vim/core/util.txt /*:QuickFixClear* +:RefactorRedo vim/refactoring.txt /*:RefactorRedo* +:RefactorUndo vim/refactoring.txt /*:RefactorUndo* +:RefactorUndoPeek vim/refactoring.txt /*:RefactorUndoPeek* +:RubyInterpreterAdd vim/ruby/buildpath.txt /*:RubyInterpreterAdd* +:RubyInterpreterList vim/ruby/buildpath.txt /*:RubyInterpreterList* +:RubyInterpreterRemove vim/ruby/buildpath.txt /*:RubyInterpreterRemove* +:RubySearch vim/ruby/search.txt /*:RubySearch* +:RubySearchContext vim/ruby/search.txt /*:RubySearchContext* +:ScalaImport vim/scala/import.txt /*:ScalaImport* +:ScalaSearch vim/scala/search.txt /*:ScalaSearch* +:ShutdownEclim vim/core/eclim.txt /*:ShutdownEclim* +:Sign vim/core/util.txt /*:Sign* +:SignClearAll vim/core/util.txt /*:SignClearAll* +:SignClearUser vim/core/util.txt /*:SignClearUser* +:Signs vim/core/util.txt /*:Signs* +:SwapWords vim/core/util.txt /*:SwapWords* +:Tcd vim/core/util.txt /*:Tcd* +:Todo vim/core/project.txt /*:Todo* +:Validate_ant vim/java/ant.txt /*:Validate_ant* +:Validate_c vim/c/validate.txt /*:Validate_c* +:Validate_css vim/html/index.txt /*:Validate_css* +:Validate_dtd vim/xml/index.txt /*:Validate_dtd* +:Validate_groovy vim/groovy/validate.txt /*:Validate_groovy* +:Validate_html vim/html/index.txt /*:Validate_html* +:Validate_java vim/java/validate.txt /*:Validate_java* +:Validate_javascript vim/javascript/index.txt /*:Validate_javascript* +:Validate_log4j vim/java/logging.txt /*:Validate_log4j* +:Validate_php vim/php/validate.txt /*:Validate_php* +:Validate_python vim/python/validate.txt /*:Validate_python* +:Validate_ruby vim/ruby/validate.txt /*:Validate_ruby* +:Validate_scala vim/scala/validate.txt /*:Validate_scala* +:Validate_webxml vim/java/webxml.txt /*:Validate_webxml* +:Validate_xml vim/xml/index.txt /*:Validate_xml* +:Validate_xsd vim/xml/index.txt /*:Validate_xsd* +:VariableCreate vim/java/classpath.txt /*:VariableCreate* +:VariableDelete vim/java/classpath.txt /*:VariableDelete* +:VariableList vim/java/classpath.txt /*:VariableList* +:VimSettings vim/core/eclim.txt /*:VimSettings* +:WorkspaceSettings vim/core/eclim.txt /*:WorkspaceSettings* +:XmlFormat vim/xml/index.txt /*:XmlFormat* +:XsdDefinition vim/xml/index.txt /*:XsdDefinition* +FeedKeys eclimd.txt /*FeedKeys* +archive-changes.html archive/changes.txt /*archive-changes.html* +archive-news.html archive/news.txt /*archive-news.html* +changes.html changes.txt /*changes.html* +cheatsheet.html cheatsheet.txt /*cheatsheet.html* +classpath-ivy vim/java/classpath.txt /*classpath-ivy* +classpath-maven vim/java/classpath.txt /*classpath-maven* +classpath-maven-pom vim/java/classpath.txt /*classpath-maven-pom* +classpath-src-javadocs vim/java/classpath.txt /*classpath-src-javadocs* +coding-style development/gettingstarted.txt /*coding-style* +com.android.ide.eclipse.adt.sdk vim/java/android.txt /*com.android.ide.eclipse.adt.sdk* +contribute.html contribute.txt /*contribute.html* +css vim/html/index.txt /*css* +development-architecture.html development/architecture.txt /*development-architecture.html* +development-commands.html development/commands.txt /*development-commands.html* +development-gettingstarted.html development/gettingstarted.txt /*development-gettingstarted.html* +development-index.html development/index.txt /*development-index.html* +development-installer.html development/installer.txt /*development-installer.html* +development-patches development/gettingstarted.txt /*development-patches* +development-plugins.html development/plugins.txt /*development-plugins.html* +dtd vim/xml/index.txt /*dtd* +eclim#web#SearchEngine vim/core/util.txt /*eclim#web#SearchEngine* +eclim#web#WordLookup vim/core/util.txt /*eclim#web#WordLookup* +eclim-gvim-embedded-focus eclimd.txt /*eclim-gvim-embedded-focus* +eclim-gvim-embedded-shortcuts eclimd.txt /*eclim-gvim-embedded-shortcuts* +eclim_encoding faq.txt /*eclim_encoding* +eclim_full_headless faq.txt /*eclim_full_headless* +eclim_memory faq.txt /*eclim_memory* +eclim_proxy faq.txt /*eclim_proxy* +eclim_troubleshoot faq.txt /*eclim_troubleshoot* +eclim_workspace faq.txt /*eclim_workspace* +eclimd-extdir eclimd.txt /*eclimd-extdir* +eclimd-headed eclimd.txt /*eclimd-headed* +eclimd-headless eclimd.txt /*eclimd-headless* +eclimd-multiworkspace eclimd.txt /*eclimd-multiworkspace* +eclimd-start eclimd.txt /*eclimd-start* +eclimd-stop eclimd.txt /*eclimd-stop* +eclimd.html eclimd.txt /*eclimd.html* +eclimd_options_windows faq.txt /*eclimd_options_windows* +eclimrc eclimd.txt /*eclimrc* +faq.html faq.txt /*faq.html* +features.html features.txt /*features.html* +g:EclimAntCompilerAdditionalErrorFormat vim/java/ant.txt /*g:EclimAntCompilerAdditionalErrorFormat* +g:EclimAntErrorsEnabled vim/java/ant.txt /*g:EclimAntErrorsEnabled* +g:EclimAntValidate vim/java/ant.txt /*g:EclimAntValidate* +g:EclimBrowser vim/core/eclim.txt /*g:EclimBrowser* +g:EclimBuffersDeleteOnTabClose vim/core/util.txt /*g:EclimBuffersDeleteOnTabClose* +g:EclimBuffersSort vim/core/util.txt /*g:EclimBuffersSort* +g:EclimBuffersSortDirection vim/core/util.txt /*g:EclimBuffersSortDirection* +g:EclimBuffersTabTracking vim/core/util.txt /*g:EclimBuffersTabTracking* +g:EclimCCallHierarchyDefaultAction vim/c/inspection.txt /*g:EclimCCallHierarchyDefaultAction* +g:EclimCSearchSingleResult vim/c/search.txt /*g:EclimCSearchSingleResult* +g:EclimCValidate vim/c/validate.txt /*g:EclimCValidate* +g:EclimCompletionMethod vim/code_completion.txt /*g:EclimCompletionMethod* +g:EclimCssValidate vim/html/index.txt /*g:EclimCssValidate* +g:EclimDjangoAdmin vim/python/django.txt /*g:EclimDjangoAdmin* +g:EclimDjangoFindAction vim/python/django.txt /*g:EclimDjangoFindAction* +g:EclimDjangoStaticPaths vim/python/django.txt /*g:EclimDjangoStaticPaths* +g:EclimDjangoStaticPattern vim/python/django.txt /*g:EclimDjangoStaticPattern* +g:EclimDtdValidate vim/xml/index.txt /*g:EclimDtdValidate* +g:EclimGroovyValidate vim/groovy/validate.txt /*g:EclimGroovyValidate* +g:EclimHighlightDebug vim/core/eclim.txt /*g:EclimHighlightDebug* +g:EclimHighlightError vim/core/eclim.txt /*g:EclimHighlightError* +g:EclimHighlightInfo vim/core/eclim.txt /*g:EclimHighlightInfo* +g:EclimHighlightTrace vim/core/eclim.txt /*g:EclimHighlightTrace* +g:EclimHighlightWarning vim/core/eclim.txt /*g:EclimHighlightWarning* +g:EclimHistoryDiffOrientation vim/core/history.txt /*g:EclimHistoryDiffOrientation* +g:EclimHtmlValidate vim/html/index.txt /*g:EclimHtmlValidate* +g:EclimJavaCallHierarchyDefaultAction vim/java/inspection.txt /*g:EclimJavaCallHierarchyDefaultAction* +g:EclimJavaCompleteCaseSensitive vim/java/complete.txt /*g:EclimJavaCompleteCaseSensitive* +g:EclimJavaDebugLineHighlight vim/java/debug.txt /*g:EclimJavaDebugLineHighlight* +g:EclimJavaDebugLineSignText vim/java/debug.txt /*g:EclimJavaDebugLineSignText* +g:EclimJavaDebugStatusWinHeight vim/java/debug.txt /*g:EclimJavaDebugStatusWinHeight* +g:EclimJavaDebugStatusWinOrientation vim/java/debug.txt /*g:EclimJavaDebugStatusWinOrientation* +g:EclimJavaDebugStatusWinWidth vim/java/debug.txt /*g:EclimJavaDebugStatusWinWidth* +g:EclimJavaHierarchyDefaultAction vim/java/inspection.txt /*g:EclimJavaHierarchyDefaultAction* +g:EclimJavaImplInsertAtCursor vim/java/methods.txt /*g:EclimJavaImplInsertAtCursor* +g:EclimJavaSearchMapping vim/java/search.txt /*g:EclimJavaSearchMapping* +g:EclimJavaSearchSingleResult vim/java/search.txt /*g:EclimJavaSearchSingleResult* +g:EclimJavaValidate vim/java/validate.txt /*g:EclimJavaValidate* +g:EclimJavascriptLintConf vim/javascript/index.txt /*g:EclimJavascriptLintConf* +g:EclimJavascriptValidate vim/javascript/index.txt /*g:EclimJavascriptValidate* +g:EclimKeepLocalHistory vim/core/history.txt /*g:EclimKeepLocalHistory* +g:EclimLocateFileCaseInsensitive vim/core/locate.txt /*g:EclimLocateFileCaseInsensitive* +g:EclimLocateFileDefaultAction vim/core/locate.txt /*g:EclimLocateFileDefaultAction* +g:EclimLocateFileFuzzy vim/core/locate.txt /*g:EclimLocateFileFuzzy* +g:EclimLocateFileScope vim/core/locate.txt /*g:EclimLocateFileScope* +g:EclimLog4jValidate vim/java/logging.txt /*g:EclimLog4jValidate* +g:EclimLogLevel vim/core/eclim.txt /*g:EclimLogLevel* +g:EclimLoggingDisabled vim/java/logging.txt /*g:EclimLoggingDisabled* +g:EclimMakeLCD vim/core/eclim.txt /*g:EclimMakeLCD* +g:EclimMenus vim/core/eclim.txt /*g:EclimMenus* +g:EclimOnlyExclude vim/core/util.txt /*g:EclimOnlyExclude* +g:EclimOnlyExcludeFixed vim/core/util.txt /*g:EclimOnlyExcludeFixed* +g:EclimOpenUrlInVimAction vim/core/util.txt /*g:EclimOpenUrlInVimAction* +g:EclimOpenUrlInVimPatterns vim/core/util.txt /*g:EclimOpenUrlInVimPatterns* +g:EclimPhpSearchSingleResult vim/php/search.txt /*g:EclimPhpSearchSingleResult* +g:EclimPhpValidate vim/php/validate.txt /*g:EclimPhpValidate* +g:EclimProjectProblemsUpdateOnSave vim/core/project.txt /*g:EclimProjectProblemsUpdateOnSave* +g:EclimProjectStatusLine vim/core/project.txt /*g:EclimProjectStatusLine* +g:EclimProjectTabTreeAutoOpen vim/core/project.txt /*g:EclimProjectTabTreeAutoOpen* +g:EclimProjectTreeActions vim/core/project.txt /*g:EclimProjectTreeActions* +g:EclimProjectTreeAutoOpen vim/core/project.txt /*g:EclimProjectTreeAutoOpen* +g:EclimProjectTreeAutoOpenProjects vim/core/project.txt /*g:EclimProjectTreeAutoOpenProjects* +g:EclimProjectTreeExpandPathOnOpen vim/core/project.txt /*g:EclimProjectTreeExpandPathOnOpen* +g:EclimProjectTreePathEcho vim/core/project.txt /*g:EclimProjectTreePathEcho* +g:EclimProjectTreeSharedInstance vim/core/project.txt /*g:EclimProjectTreeSharedInstance* +g:EclimPromptListStartIndex vim/core/eclim.txt /*g:EclimPromptListStartIndex* +g:EclimPythonSearchSingleResult vim/python/search.txt /*g:EclimPythonSearchSingleResult* +g:EclimPythonValidate vim/python/validate.txt /*g:EclimPythonValidate* +g:EclimQuickFixOpen vim/core/project.txt /*g:EclimQuickFixOpen* +g:EclimRefactorDiffOrientation vim/refactoring.txt /*g:EclimRefactorDiffOrientation* +g:EclimRefactorDiffOrientation_java vim/java/refactor.txt /*g:EclimRefactorDiffOrientation_java* +g:EclimRubySearchSingleResult vim/ruby/search.txt /*g:EclimRubySearchSingleResult* +g:EclimRubyValidate vim/ruby/validate.txt /*g:EclimRubyValidate* +g:EclimScalaSearchSingleResult vim/scala/search.txt /*g:EclimScalaSearchSingleResult* +g:EclimScalaValidate vim/scala/validate.txt /*g:EclimScalaValidate* +g:EclimShowCurrentError vim/core/eclim.txt /*g:EclimShowCurrentError* +g:EclimSignLevel vim/core/eclim.txt /*g:EclimSignLevel* +g:EclimTodoSearchExtensions vim/core/project.txt /*g:EclimTodoSearchExtensions* +g:EclimTodoSearchPattern vim/core/project.txt /*g:EclimTodoSearchPattern* +g:EclimWebXmlValidate vim/java/webxml.txt /*g:EclimWebXmlValidate* +g:EclimXmlValidate vim/xml/index.txt /*g:EclimXmlValidate* +g:EclimXsdValidate vim/xml/index.txt /*g:EclimXsdValidate* +g:HtmlDjangoCompleteEndTag vim/python/django.txt /*g:HtmlDjangoCompleteEndTag* +g:HtmlDjangoUserBodyElements vim/python/django.txt /*g:HtmlDjangoUserBodyElements* +g:HtmlDjangoUserFilters vim/python/django.txt /*g:HtmlDjangoUserFilters* +g:HtmlDjangoUserTags vim/python/django.txt /*g:HtmlDjangoUserTags* +gettinghelp.html gettinghelp.txt /*gettinghelp.html* +gettingstarted-android gettingstarted.txt /*gettingstarted-android* +gettingstarted-coding gettingstarted.txt /*gettingstarted-coding* +gettingstarted-create gettingstarted.txt /*gettingstarted-create* +gettingstarted-maven gettingstarted.txt /*gettingstarted-maven* +gettingstarted.html gettingstarted.txt /*gettingstarted.html* +gvim-embedded eclimd.txt /*gvim-embedded* +html vim/html/index.txt /*html* +htmldjango vim/python/django.txt /*htmldjango* +index.html index.txt /*index.html* +install-headless install.txt /*install-headless* +install-source install.txt /*install-source* +install.html install.txt /*install.html* +installer install.txt /*installer* +installer-automated install.txt /*installer-automated* +installer-issues install.txt /*installer-issues* +installer-proxy install.txt /*installer-proxy* +log4j vim/java/logging.txt /*log4j* +org.eclim.java.checkstyle.config vim/java/validate.txt /*org.eclim.java.checkstyle.config* +org.eclim.java.checkstyle.onvalidate vim/java/validate.txt /*org.eclim.java.checkstyle.onvalidate* +org.eclim.java.checkstyle.properties vim/java/validate.txt /*org.eclim.java.checkstyle.properties* +org.eclim.java.format.strip_trialing_whitespace vim/java/format.txt /*org.eclim.java.format.strip_trialing_whitespace* +org.eclim.java.import.exclude vim/java/import.txt /*org.eclim.java.import.exclude* +org.eclim.java.import.package_separation_level vim/java/import.txt /*org.eclim.java.import.package_separation_level* +org.eclim.java.junit.envvars vim/java/unittests.txt /*org.eclim.java.junit.envvars* +org.eclim.java.junit.jvmargs vim/java/unittests.txt /*org.eclim.java.junit.jvmargs* +org.eclim.java.junit.output_dir vim/java/unittests.txt /*org.eclim.java.junit.output_dir* +org.eclim.java.junit.sysprops vim/java/unittests.txt /*org.eclim.java.junit.sysprops* +org.eclim.java.logging.impl vim/java/logging.txt /*org.eclim.java.logging.impl* +org.eclim.java.logging.template vim/java/logging.txt /*org.eclim.java.logging.template* +org.eclim.java.run.mainclass vim/java/java.txt /*org.eclim.java.run.mainclass* +org.eclim.java.search.sort vim/java/search.txt /*org.eclim.java.search.sort* +org.eclim.project.version vim/core/eclim.txt /*org.eclim.project.version* +org.eclim.user.email vim/core/eclim.txt /*org.eclim.user.email* +org.eclim.user.name vim/core/eclim.txt /*org.eclim.user.name* +org.eclipse.jdt.core.compiler.source vim/java/validate.txt /*org.eclipse.jdt.core.compiler.source* +org.eclipse.jdt.ui.importorder vim/java/import.txt /*org.eclipse.jdt.ui.importorder* +pid eclimd.txt /*pid* +relatedprojects.html relatedprojects.txt /*relatedprojects.html* +troubleshooting faq.txt /*troubleshooting* +ts_completion faq.txt /*ts_completion* +ts_exception faq.txt /*ts_exception* +ts_ftplugin faq.txt /*ts_ftplugin* +ts_incompatible_plugins faq.txt /*ts_incompatible_plugins* +ts_signs_misplaced faq.txt /*ts_signs_misplaced* +ts_workspace faq.txt /*ts_workspace* +uninstall install.txt /*uninstall* +uninstall-automated install.txt /*uninstall-automated* +vim-c-complete.html vim/c/complete.txt /*vim-c-complete.html* +vim-c-index.html vim/c/index.txt /*vim-c-index.html* +vim-c-inspection.html vim/c/inspection.txt /*vim-c-inspection.html* +vim-c-project.html vim/c/project.txt /*vim-c-project.html* +vim-c-search.html vim/c/search.txt /*vim-c-search.html* +vim-c-validate.html vim/c/validate.txt /*vim-c-validate.html* +vim-code_completion.html vim/code_completion.txt /*vim-code_completion.html* +vim-core-eclim.html vim/core/eclim.txt /*vim-core-eclim.html* +vim-core-history.html vim/core/history.txt /*vim-core-history.html* +vim-core-index.html vim/core/index.txt /*vim-core-index.html* +vim-core-locate.html vim/core/locate.txt /*vim-core-locate.html* +vim-core-project.html vim/core/project.txt /*vim-core-project.html* +vim-core-util.html vim/core/util.txt /*vim-core-util.html* +vim-dltk-buildpath.html vim/dltk/buildpath.txt /*vim-dltk-buildpath.html* +vim-groovy-complete.html vim/groovy/complete.txt /*vim-groovy-complete.html* +vim-groovy-index.html vim/groovy/index.txt /*vim-groovy-index.html* +vim-groovy-validate.html vim/groovy/validate.txt /*vim-groovy-validate.html* +vim-html-index.html vim/html/index.txt /*vim-html-index.html* +vim-index.html vim/index.txt /*vim-index.html* +vim-java-android.html vim/java/android.txt /*vim-java-android.html* +vim-java-ant.html vim/java/ant.txt /*vim-java-ant.html* +vim-java-classpath.html vim/java/classpath.txt /*vim-java-classpath.html* +vim-java-complete.html vim/java/complete.txt /*vim-java-complete.html* +vim-java-debug.html vim/java/debug.txt /*vim-java-debug.html* +vim-java-format.html vim/java/format.txt /*vim-java-format.html* +vim-java-import.html vim/java/import.txt /*vim-java-import.html* +vim-java-index.html vim/java/index.txt /*vim-java-index.html* +vim-java-inspection.html vim/java/inspection.txt /*vim-java-inspection.html* +vim-java-java.html vim/java/java.txt /*vim-java-java.html* +vim-java-javadoc.html vim/java/javadoc.txt /*vim-java-javadoc.html* +vim-java-logging.html vim/java/logging.txt /*vim-java-logging.html* +vim-java-maven.html vim/java/maven.txt /*vim-java-maven.html* +vim-java-methods.html vim/java/methods.txt /*vim-java-methods.html* +vim-java-refactor.html vim/java/refactor.txt /*vim-java-refactor.html* +vim-java-search.html vim/java/search.txt /*vim-java-search.html* +vim-java-types.html vim/java/types.txt /*vim-java-types.html* +vim-java-unittests.html vim/java/unittests.txt /*vim-java-unittests.html* +vim-java-validate.html vim/java/validate.txt /*vim-java-validate.html* +vim-java-webxml.html vim/java/webxml.txt /*vim-java-webxml.html* +vim-javascript-index.html vim/javascript/index.txt /*vim-javascript-index.html* +vim-php-buildpath.html vim/php/buildpath.txt /*vim-php-buildpath.html* +vim-php-complete.html vim/php/complete.txt /*vim-php-complete.html* +vim-php-index.html vim/php/index.txt /*vim-php-index.html* +vim-php-search.html vim/php/search.txt /*vim-php-search.html* +vim-php-validate.html vim/php/validate.txt /*vim-php-validate.html* +vim-python-complete.html vim/python/complete.txt /*vim-python-complete.html* +vim-python-django.html vim/python/django.txt /*vim-python-django.html* +vim-python-index.html vim/python/index.txt /*vim-python-index.html* +vim-python-path.html vim/python/path.txt /*vim-python-path.html* +vim-python-search.html vim/python/search.txt /*vim-python-search.html* +vim-python-validate.html vim/python/validate.txt /*vim-python-validate.html* +vim-refactoring.html vim/refactoring.txt /*vim-refactoring.html* +vim-ruby-buildpath.html vim/ruby/buildpath.txt /*vim-ruby-buildpath.html* +vim-ruby-complete.html vim/ruby/complete.txt /*vim-ruby-complete.html* +vim-ruby-index.html vim/ruby/index.txt /*vim-ruby-index.html* +vim-ruby-search.html vim/ruby/search.txt /*vim-ruby-search.html* +vim-ruby-validate.html vim/ruby/validate.txt /*vim-ruby-validate.html* +vim-scala-complete.html vim/scala/complete.txt /*vim-scala-complete.html* +vim-scala-import.html vim/scala/import.txt /*vim-scala-import.html* +vim-scala-index.html vim/scala/index.txt /*vim-scala-index.html* +vim-scala-search.html vim/scala/search.txt /*vim-scala-search.html* +vim-scala-validate.html vim/scala/validate.txt /*vim-scala-validate.html* +vim-search.html vim/search.txt /*vim-search.html* +vim-settings.html vim/settings.txt /*vim-settings.html* +vim-validation.html vim/validation.txt /*vim-validation.html* +vim-xml-index.html vim/xml/index.txt /*vim-xml-index.html* +xml vim/xml/index.txt /*xml* +xml-validation vim/xml/index.txt /*xml-validation* +xsd vim/xml/index.txt /*xsd*