*neocomplcache.txt*	Ultimate auto completion system for Vim

Version: 7.1
Author : Shougo <Shougo.Matsu@gmail.com>
License: MIT license  {{{
    Permission is hereby granted, free of charge, to any person obtaining
    a copy of this software and associated documentation files (the
    "Software"), to deal in the Software without restriction, including
    without limitation the rights to use, copy, modify, merge, publish,
    distribute, sublicense, and/or sell copies of the Software, and to
    permit persons to whom the Software is furnished to do so, subject to
    the following conditions:
    The above copyright notice and this permission notice shall be included
    in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
}}}

CONTENTS					*neocomplcache-contents*

Introduction		|neocomplcache-introduction|
Install			|neocomplcache-install|
Interface		|neocomplcache-interface|
  Commands		  |neocomplcache-commands|
  Variables		  |neocomplcache-variables|
  Key mappings		  |neocomplcache-key-mappings|
  Functions		  |neocomplcache-functions|
Examples		|neocomplcache-examples|
Sources			|neocomplcache-sources|
  User sources		  |neocomplcache-user-sources|
Create source		|neocomplcache-create-source|
FAQ			|neocomplcache-faq|
Changelog		|neocomplcache-changelog|

==============================================================================
INTRODUCTION					*neocomplcache-introduction*

*neocomplcache* performs keyword completion by maintaining a cache of keywords in
the current buffer. Because I implemented it by paying own expenses unlike the
keyword completion including the Vim composing type, neocomplcache can be
customized flexibly. Unfortunately neocomplcache may use more memory than
other plugins.

						*neocomplcache-version5*
Because all variable names are changed in neocomplcache Ver.5, there is no
backward compatibility. In the case of an upgrade, you should use the next
script which Mr.thinca made.
http://gist.github.com/422503

==============================================================================
INSTALL						*neocomplcache-install*

1: Extract the file and put files in your Vim directory
   (usually ~/.vim/ or Program Files/Vim/vimfiles on Windows).
2: Execute |:NeoComplCacheEnable| command or set
let g:neocomplcache_enable_at_startup = 1
in your .vimrc.

						*neocomplcache-asyncronous*
With neocomplcache Ver.6.0, if |vimproc| is installed, neocomplcache creates
the cache asynchronously.

vimproc is distributed at: http://github.com/Shougo/vimshell/tree/master

To use vimproc, you must compile it. Refer to the vimproc documentation.

Note: Snippets feature(snippets_complete source) was splitted from Ver.7.
      If you used it, please install snippets_complete source manually.

https://github.com/Shougo/neocomplcache-snippets-complete

==============================================================================
INTERFACE					*neocomplcache-interface*

------------------------------------------------------------------------------
COMMANDS 					*neocomplcache-commands*

:NeoComplCacheEnable				*:NeoComplCacheEnable*
		Validate neocomplcache and initialize it.
		Warning: Conventional cache disappears.

:NeoComplCacheDisable				*:NeoComplCacheDisable*
		Invalidate neocomplcache and clean it up.

:NeoComplCacheToggle				*:NeoComplCacheToggle*
		Change a lock state of neocomplcache.
		While locking neocomplcache, automatic completion is not
		possible.
		Note: This command enables neocomplcache when neocomplcache is
		disabled.

:Neco [{anim-number}] 				*:Neco*
		Secret.

:NeoComplCacheLock				*:NeoComplCacheLock*
		Lock neocomplcache.
		While locking neocomplcache, manual completion is possible.
		The lock status is buffer local.
		Note: This command is disabled when neocomplcache is disabled.

:NeoComplCacheUnlock				*:NeoComplCacheUnlock*
		Unlock neocomplcache.
		Note: This command is disabled when neocomplcache is disabled.

:NeoComplCacheLockSource {source-name}		*:NeoComplCacheLockSource*
		Disable {source-name} source completion. Disable state is
		buffer local.

:NeoComplCacheUnlockSource {source-name}	*:NeoComplCacheUnlockSource*
		Unlock {source-name} source completion.

:NeoComplCacheAutoCompletionLength		*:NeoComplCacheAutoCompletionLength*
		Change start length of automatic completion.
		This length is buffer local.

:NeoComplCacheCachingBuffer [bufname]		*:NeoComplCacheCachingBuffer*
		Caching [bufname] buffer.  Warning: considerably take time,
		for the big buffer.  Select current buffer when [bufname]
		omitted.  When [bufname] buffer is not cacheed, perform only
		simple cacheing.

:NeoComplCacheCachingSyntax [filetype]		*:NeoComplCacheCachingSyntax*
		Caching [filetype] syntax file.
		Select current buffer filetype when [filetype] omitted.

:NeoComplCacheCachingDictionary [filetype]	*:NeoComplCacheCachingDictionary*
		Caching [filetype] dictionary file.
		Select current buffer filetype when [filetype] omitted.

:NeoComplCacheCachingTags		*:NeoComplCacheCachingTags*
		Caching tags file in current buffer.

:NeoComplCacheCachingInclude [bufname]		*:NeoComplCacheCachingInclude*
		Caching [bufname] include file.
		Select current buffer name when [bufname] omitted.

:NeoComplCacheCachingDisable [bufname]		*:NeoComplCacheCachingDisable*
		Disable [bufname] buffer's cache.
		The cache will be deleted.
		Select current buffer when [bufname] omitted.

:NeoComplCacheCachingEnable [bufname]		*:NeoComplCacheCachingEnable*
		Enable [bufname] buffer's cache.
		Select current buffer when [bufname] omitted.

:NeoComplCachePrintSource [bufname]		*:NeoComplCachePrintSource*
		Output [bufname] buffer's cache in current buffer.
		This command is for debug.
		Select current buffer when [bufname] omitted.
		For a command for debugging, a user will not need to use it mainly.

:NeoComplCacheOutputKeyword [bufname]		*:NeoComplCacheOutputKeyword*
		Write the keyword which cacheed [bufname] buffer in current
		buffer.  Select current buffer when [bufname] omitted.  When
		you make a dictionary file by yourself, it may be
		convenient.

:NeoComplCacheCreateTags [bufname]		*:NeoComplCacheCreateTags*
		Create tags from [bufname] buffer.
		Select current buffer when [bufname] omitted.

:NeoComplCacheSetFileType [filetype]		*:NeoComplCacheSetFileType*
		Change filetype to [filetype] in current buffer.
		This filetype is only used neocomplcache.
		Note: You can get current filetype by
		|neocomplcache#get_context_filetype()|

------------------------------------------------------------------------------
VARIABLES 					*neocomplcache-variables*

g:neocomplcache_enable_at_startup		*g:neocomplcache_enable_at_startup*
		This variable controls whether I validate neocomplcache at
		the time of Vim start.
		Note: This option must set it in .vimrc(_vimrc). NOT IN
		.gvimrc(_gvimrc)!
		
		Because default value is 0, you cannot use neocomplcache
		unless you validate it by manual operation.

g:neocomplcache_max_list			*g:neocomplcache_max_list*
		This variable controls the number of candidates displayed in
		a pop-up menu.  The case beyond this value is cut down a
		candidate.
		
		Default value is 100.

g:neocomplcache_max_keyword_width		*g:neocomplcache_max_keyword_width*
		This variable controls the indication width of a candidate
		displayed in a pop-up menu.  The case beyond this value is
		cut down properly.
		
		Default value is 50.

g:neocomplcache_max_menu_width			*g:neocomplcache_max_menu_width*
		This variable controls the indication width of a menu displayed
		in a pop-up menu.  The case beyond this value is cut down.
		
		Default value is 15.

g:neocomplcache_auto_completion_start_length	*g:neocomplcache_auto_completion_start_length*
		This variable controls the number of the input completion
		at the time of key input automatically.
		
		Default value is 2.

g:neocomplcache_manual_completion_start_length	*g:neocomplcache_manual_completion_start_length*
		This variable controls the number of the input completion
		at the time of manual completion.  It is convenient when you
		reduce this value, but may get heavy when you deleted a
		letter in <C-h> or <BS> at popup indication time.
		
		Default value is 0.

g:neocomplcache_min_keyword_length		*g:neocomplcache_min_keyword_length*
		In a buffer or dictionary files, this variable controls
		length of keyword becoming the object of the completion at
		the minimum.
		
		Default value is 4.

g:neocomplcache_min_syntax_length		*g:neocomplcache_min_syntax_length*
		In syntax files, this variable controls length of keyword
		becoming the object of the completion at the minimum.
		
		Default value is 4.

g:neocomplcache_enable_ignore_case		*g:neocomplcache_enable_ignore_case*
		When neocomplcache looks for candidate completion, this
		variable controls whether neocomplcache ignores the upper-
		and lowercase.  If it is 1, neocomplcache ignores case.
		
		Default value is 'ignorecase'.

g:neocomplcache_enable_smart_case		*g:neocomplcache_enable_smart_case*
		When a capital letter is included in input, neocomplcache do
		not ignore the upper- and lowercase.
		
		Default value is 'infercase'.

g:neocomplcache_disable_auto_complete		*g:neocomplcache_disable_auto_complete*
		This variable controls whether you invalidate automatic
		completion.  If it is 1, automatic completion becomes
		invalid, but can use the manual completion by <C-x><C-u>.
		
		Default value is 0.

g:neocomplcache_enable_wildcard			*g:neocomplcache_enable_wildcard*
		This variable controls whether neocomplcache accept wild
		card character '*' for input-saving.
		
		Default value is 1.

g:neocomplcache_enable_cursor_hold_i		*g:neocomplcache_enable_cursor_hold_i*
		This variable controls whether neocomplcache use |CursorHoldI| event
		when complete candidates.
		Note: You should not use this option if less than Vim 7.3.418.
		Note: This option must be set before call |:NeoComplCacheEnable|.
		
		Default value is 0.

g:neocomplcache_cursor_hold_i_time		*g:neocomplcache_cursor_hold_i_time*
		If g:neocomplcache_enable_cursor_hold_i is non zero and in
		insert mode, this value changes 'updatetime' option.

		Default value is 300.

g:neocomplcache_enable_insert_char_pre		*g:neocomplcache_enable_insert_char_pre*
		This variable controls whether neocomplcache use
		|InsertCharPre| event when complete candidates.
		Note: You should not use this option if less than Vim 7.3.461.
		Note: This option must be set before call |:NeoComplCacheEnable|.
		Note: This option is experimental.
		
		Default value is 0.

g:neocomplcache_enable_auto_select		*g:neocomplcache_enable_auto_select*
		When neocomplcache displays candidates, this option controls
		whether neocomplcache selects the first candidate
		automatically.  If you enable this option, neocomplcache's
		completion behavior is like |AutoComplPop|.
		
		Default value is 0.

g:neocomplcache_enable_auto_delimiter		*g:neocomplcache_enable_auto_delimiter*
		This option controls whether neocomplcache insert delimiter
		automatically.  For example, /(filename) or #(Vim script).
		
		Default value is 0.

g:neocomplcache_enable_camel_case_completion	*g:neocomplcache_enable_camel_case_completion*
		When you input a capital letter, this variable controls
		whether neocomplcache takes an ambiguous searching as an end
		of the words in it.  For example, neocomplcache come to
		match it with ArgumentsException when you input it with AE.
		
		Default value is 0.

g:neocomplcache_enable_underbar_completion	*g:neocomplcache_enable_underbar_completion*
		When you input _, this variable controls whether
		neocomplcache takes an ambiguous searching as an end of the
		words in it.  For example, neocomplcache come to match it
		with "public_html" when you input it with "p_h".
		
		Default value is 0.

g:neocomplcache_enable_fuzzy_completion		*g:neocomplcache_enable_fuzzy_completion*
		When you input one character, this variable controls whether
		neocomplcache takes an ambiguous searching as an end of the
		words in it.  For example, neocomplcache come to match it
		with "public_html" or "PublicHtml" when you input it with "puh".
		Note: If |g:neocomplcache_fuzzy_completion_start_length| is 3,
		"ph" does not complete "public_html".
		Note: This match is too heavy. So, it is enabled when your
		input length is longer than or equal to
		|g:neocomplcache_fuzzy_completion_start_length| and less than
		20 characters.
		
		Default value is 0.

g:neocomplcache_fuzzy_completion_start_length	*g:neocomplcache_fuzzy_completion_start_length*
		This variable controls length of fuzzy completion start length.
		For example, If this variable is "3", third and after input characters are
		fuzzy matched.  But first and second input characters are not
		fuzzy matched.
		Note: If this variable changed, completion speed may be too slow.

		Default value is 3.

g:neocomplcache_enable_caching_message		*g:neocomplcache_enable_caching_message*
		When make cache, this variable controls whether neocomplcache
		displays the message in Command-line.
		
		Default value is 1.

g:neocomplcache_caching_limit_file_size		*g:neocomplcache_caching_limit_file_size*
		This variable set file size to make a cache of a file.  If
		open file is bigger than this size, neocomplcache do not
		make a cache.
		
		Default value is 500000.

g:neocomplcache_disable_caching_file_path_pattern
						*g:neocomplcache_disable_caching_file_path_pattern*
		This variable set a pattern of the buffer file path. If matched it,
		neocomplcache does not save a cache of the buffer. When it is
		an empty character string, neocomplcache will ignore.
		
		Default value is ''.

g:neocomplcache_lock_buffer_name_pattern	*g:neocomplcache_lock_buffer_name_pattern*
		This variable set a pattern of the buffer name. If matched it,
		neocomplcache does not complete automatically. When it is an
		empty character string, neocomplcache will ignore.
		
		Default value is ''.

g:neocomplcache_compare_function		*g:neocomplcache_compare_function*
		This variable set compare candidates function.
		The compare function specification is same to |sort()|
		compare function. If you change compare function, you must
		create compare function.
		
		Default value is 'neocomplcache#compare_rank'.

g:neocomplcache_enable_prefetch			*g:neocomplcache_enable_prefetch*
		This variable controls whether neocomplcache prefetch.  This
		variable is non 0, neocomplcache don't flick in auto
		completion.
		Note: This variable has side effect. Partial function (ex:
		|complete_check()|) is disabled in completefunc.
		Note: It this variable is 0, input problem may be occurred in
		using uim-skk or other IME in GVim.
		
		Default value is 0(above equal than 7.3.519).
		Default value is 1(|+xim| and GUI version).

g:neocomplcache_lock_iminsert			*g:neocomplcache_lock_iminsert*
		This variable is non 0, neocomplcache lock when 'iminsert' is
		non zero.
		
		Default value is 0.

g:neocomplcache_temporary_dir			*g:neocomplcache_temporary_dir*
		This variable appoints the directory that neocomplcache
		begins to write a file at one time.  When there is not the
		directory which appointed here, it is made.  For example,
		keyword_complete.vim stores cache of the keyword in this
		'keyword_cache' sub directory.
		
		Default value is '~/.neocon'.

g:neocomplcache_keyword_patterns		*g:neocomplcache_keyword_patterns*
		This dictionary records regular expression to recognize a
		keyword pattern of the next than a cursor.  The form is the
		same as|g:neocomplcache_keyword_patterns|.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.
>
		" Examples:
		if !exists('g:neocomplcache_keyword_patterns')
		  let g:neocomplcache_keyword_patterns = {}
		endif
		let g:neocomplcache_keyword_patterns['default'] = '\h\w*'
<
g:neocomplcache_next_keyword_patterns		*g:neocomplcache_next_keyword_patterns*
		This dictionary records keyword patterns to completion.
		This is appointed in regular expression every file type.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_omni_patterns			*g:neocomplcache_omni_patterns*
		This dictionary records keyword patterns to Omni completion.
		This is appointed in regular expression every file type.
		If this pattern is not defined, neocomplcache don't call
		|omnifunc|. For example, ruby and php omnifunc are disabled,
		because they are too slow.
		
		Because it is complicated, refer to s:source.initialize()
		autoload/neocomplcache/sources/omni_complete.vim for the
		initial value.
>
		" Examples:
		if !exists('g:neocomplcache_omni_patterns')
		let g:neocomplcache_omni_patterns = {}
		endif
		let g:neocomplcache_omni_patterns.ruby = '[^. *\t]\.\h\w*\|\h\w*::'
		let g:neocomplcache_omni_patterns.php = '[^. \t]->\h\w*\|\h\w*::'
		let g:neocomplcache_omni_patterns.c = '[^.[:digit:] *\t]\%(\.\|->\)'
		let g:neocomplcache_omni_patterns.cpp = '[^.[:digit:] *\t]\%(\.\|->\)\|\h\w*::'
<
g:neocomplcache_tags_filter_patterns		*g:neocomplcache_tags_filter_patterns*
		This dictionary records  a pattern to filter a candidate in
		the tag completion.  For example, it can exclude a candidate
		beginning in _ in file type of C/C++.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_tags_caching_limit_file_size	*g:neocomplcache_tags_caching_limit_file_size*
		This variable set file size to make a cache of a file in
		tags_complete source. If open file is bigger than this size,
		neocomplcache do not make a tags cache.
		
		Default value is 500000.

g:neocomplcache_same_filetype_lists		*g:neocomplcache_same_filetype_lists*
		It is a dictionary to connect file type mutually.  It is
		effective at time to let you refer to c and cpp mutually.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_dictionary_filetype_lists	*g:neocomplcache_dictionary_filetype_lists*
		It is a dictionary to connect a dictionary file with file
		type.  The dictionary's key is filetype and comma-separated
		multiple value is a path to a dictionary file.  If this
		variable is empty, neocomplcache use 'dictionary' option.
		When you set "text" key, you will appoint dictionary files in
		text mode.
		
		Default value is {}.

g:neocomplcache_dictionary_patterns		*g:neocomplcache_dictionary_patterns*
		It is a dictionary to dictionary keyword patterns.  The
		dictionary's key is filetype and value is keyword pattern.
		If this variable is empty, neocomplcache use
		|g:neocomplcache_keyword_patterns| option.
		
		Default value is {}.

g:neocomplcache_context_filetype_lists		*g:neocomplcache_context_filetype_lists*
		It is a dictionary to define context filetypes.
		The item is a list of dictionary.
		Note: g:neocomplcache_filetype_include_lists is deprecated name.
		
		The keys and values are below.
		"filetype" : includes filetype name.
		"start" : filetype start pattern.
		"end" : filetype end pattern. You can use \1 to refer start's
			matched pattern.
>
		" Examples:
		if !exists('g:neocomplcache_context_filetype_lists')
		let g:neocomplcache_context_filetype_lists = {}
		endif
		let g:neocomplcache_context_filetype_lists.perl6 =
		\ [{'filetype' : 'pir', 'start' : 'Q:PIR\s*{', 'end' : '}'}]
		let g:neocomplcache_context_filetype_lists.vim =
		\ [{'filetype' : 'python', 'start' : '^\s*python <<\s*\(\h\w*\)', 'end' : '^\1'}]
<
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_text_mode_filetypes		*g:neocomplcache_text_mode_filetypes*
		It is a dictionary to define text mode filetypes. The
		dictionary's key is filetype and value is number.  If the value
		is non-zero, this filetype is text mode.  In text mode,
		neocomplcache supports writing English.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_ctags_program			*g:neocomplcache_ctags_program*
		It is the path to the ctags command.  If this command is not
		installed, include_complete is disabled.
		
		Default value is "ctags".

g:neocomplcache_ctags_arguments_list		*g:neocomplcache_ctags_arguments_list*
		It is the dictionary of the character string to set a value
		to give as an argument of the commands when buffer_complete
		and include_complete use a ctags command.  The dictionary's
		key is filetype.
		
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_include_paths			*g:neocomplcache_include_paths*
		It is the variable to enumerate path of the include file
		every file type.  When there is not it, 'path' is used.
		Refer to 'path' for the description form. It is the
		dictionary of the character string that assumed file type a
		key.
		
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/include_complete.vim for the
		initial value.

g:neocomplcache_include_exprs			*g:neocomplcache_include_exprs*
		It is the expression string of the line analysis to perform
		to acquire an include file name.  When there is not it,
		'includeexpr' is used.  Refer to 'includeexpr' for the
		description form. It is the dictionary of the character
		string that assumed file type a key.
		
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/include_complete.vim for the
		initial value.

g:neocomplcache_include_patterns		*g:neocomplcache_include_patterns*
		This variable appoints the pattern of the include command.
		When there is not it, 'include' is used.  Refer to 'include'
		for the description form. It is the dictionary of the
		character string that assumed file type a key.
		
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/include_complete.vim for the
		initial value.

g:neocomplcache_include_functions		*g:neocomplcache_include_functions*
		This variable appoints the function name of the include command.
		When there is not it, ignored. It is the dictionary of the
		function name string that assumed file type a key.
		
		The function args are {lines} and {path}.
		{lines} is the list of buffer lines.
		{path} is the include path.
		The return value is the list of include files.
		
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/include_complete.vim for the
		initial value.

g:neocomplcache_include_max_processes		*g:neocomplcache_include_max_processes*
		This variable appoints the max number of include processes.
		When this variable is 0, include process will be disabled.
		
		Default value is 20.

g:neocomplcache_filename_include_exprs		*g:neocomplcache_filename_include_exprs*
		It is the expression string of the line analysis to perform
		to substitute an include file name.  When there is not it,
		ignored.  Refer to 'includeexpr' for the
		description form. It is the dictionary of the character
		string that assumed file type a key.
		
		Example: Perl
>
		let g:neocomplcache_filename_include_exprs.perl =
		\ 'fnamemodify(substitute(v:fname, "/", "::", "g"), ":r")'
<
		
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/filename_complete.vim for the
		initial value.

g:neocomplcache_filename_include_exts		*g:neocomplcache_filename_include_exts*
		It is the list of include file name extensions. When there
		is not it, all file name is used. It is the dictionary of
		the list that assumed file type a key.
		
		Example: C++
>
		let g:neocomplcache_filename_include_exts.cpp =
		\ ['', 'h', 'hpp', 'hxx']
<
		Because it is complicated, refer to s:source.initialize() in
		autoload/neocomplcache/sources/filename_complete.vim for the
		initial value.

g:neocomplcache_member_prefix_patterns		*g:neocomplcache_member_prefix_patterns*
		This variable appoints a prefix pattern to complete a member
		in buffer_complete.
		This is appointed in regular expression every file type.
		If filetype key is not set, disable member completion.
		
		Because it is complicated, refer in
		autoload/neocomplcache/sources/buffer_complete.vim for the
		initial value.

g:neocomplcache_member_patterns			*g:neocomplcache_member_patterns*
		This variable appoints a keyword pattern to complete a member
		in buffer_complete.
		This is appointed in regular expression every file type.
		If filetype key is not set, use filetype "default" setting.
		
		Because it is complicated, refer in
		autoload/neocomplcache/sources/buffer_complete.vim for the
		initial value.

g:neocomplcache_delimiter_patterns		*g:neocomplcache_delimiter_patterns*
		This variable appoints a delimiter pattern to smart complete a
		function.  This is appointed in regular expression's string
		list every file type.
>
		" Examples:
		if !exists('g:neocomplcache_delimiter_patterns')
		let g:neocomplcache_delimiter_patterns= {}
		endif
		let g:neocomplcache_delimiter_patterns.vim = ['#']
		let g:neocomplcache_delimiter_patterns.cpp = ['::']
<
		Because it is complicated, refer to neocomplcache#enable() in
		autoload/neocomplcache.vim for the initial value.

g:neocomplcache_omni_functions			*g:neocomplcache_omni_functions*
		This dictionary which appoints |omni_complete| call functions.
		The key is |&filetype|. The value is omnifunc String or List of
		omnifunc String. If
		g:neocomplcache_omni_function_list[|&filetype|] is undefined,
		|omni_complete| calls |omnifunc|.
		If the key is "_", used for all filetypes.
		
		Default value is {}.

g:neocomplcache_vim_completefuncs		*g:neocomplcache_vim_completefuncs*
		This dictionary which appoints |vim_complete| call function
		when completes custom and customlist command.  The key is
		command name. The value is function name.
>
		" Examples:
		if !exists('g:neocomplcache_vim_completefuncs')
		  let g:neocomplcache_vim_completefuncs = {}
		endif
		let g:neocomplcache_vim_completefuncs.Ref = 'ref#complete'
<
		Default value is {}.

g:neocomplcache_source_disable			*g:neocomplcache_source_disable*
		The dictionary which appoints whether you invalidate a
		source. With a source name as a key, it becomes invalid by
		making a value 1.
		Note: g:neocomplcache_plugin_disable is deprecated name.
		
		Default value is {}.

g:neocomplcache_source_completion_length	*g:neocomplcache_source_completion_length*
		It is a dictionary to control each source's completion
		length.  For example, you can prolong heavy source's
		completion length.
		Note: g:neocomplcache_plugin_completion_length is deprecated name.
		
		Default value is {}.

g:neocomplcache_source_rank			*g:neocomplcache_source_rank*
		It is a dictionary to control each source's completion
		priority.
		The key is source name and the value is source priority number.
		Note: g:neocomplcache_plugin_rank is deprecated name.
		
		The default rank of each sources:
		filename_complete : 3
		dictionary_complete : 4
		buffer_complete : 5
		syntax_complete : 7
		include_complete : 8
		snippets_complete : 8
		vim_complete : 300
		omni_complete : 300
		other plugin sources : 5
		other completefunc sources : 10
		other ftplugin sources : 100
		
		Ex:
>
		let g:neocomplcache_source_rank = {
			\ 'snippets_complete' : 100,
			\ 'abbrev_complete' : 50,
			\ }
<
		Default value is set by each sources.

g:neocomplcache_force_overwrite_completefunc	*g:neocomplcache_force_overwrite_completefunc*
		If this variable is 1, neocomplcache force overwrite
		'completefunc' option. This variable is useful for other
		plugin overwrite 'completefunc'.  But other plugin's
		'completefunc' is disabled.
		
		Default value is 0.

g:neocomplcache_release_cache_time		*g:neocomplcache_release_cache_time*
		This variable defines time of automatic released cache by a second unit.
		
		Default value is 900.

g:neocomplcache_use_vimproc			*g:neocomplcache_use_vimproc*
		This variable is non 0, neocomplcache use |vimproc|.
		Note: If this variable is non 0, neocomplcache will make cache
		asynchronously.
		
		Default value is vimproc auto detection result.

g:neocomplcache_ignore_composite_filetype_lists	*g:neocomplcache_ignore_composite_filetype_lists*
		It is a dictionary to ignore composite file type.
		The dictionary's key is composite filetype and value is
		filetype.
		Ex:
>
		let g:neocomplcache_ignore_composite_filetype_lists = {
			\ 'ruby.spec' : 'ruby'
			\ }
<
		If you open filetype like |ruby.spec|, completion is
		intended for |ruby| and |spec|.
		But if you only want to complete |ruby| filetype,
		you can set this variable to ignore |spec|.
		
		Default value is {}.

------------------------------------------------------------------------------
FUNCTIONS 					*neocomplcache-functions*

neocomplcache#get_context_filetype()		*unite#get_context_filetype()*
		Get current context filetype.

------------------------------------------------------------------------------
KEY MAPPINGS 					*neocomplcache-key-mappings*

neocomplcache#start_manual_complete([{sources}])
						*neocomplcache#start_manual_complete()*
		Use this function on inoremap <expr>.  The keymapping call the
		completion of neocomplcache.  When you rearrange the completion
		of the Vim standard, you use it.
		If you give {sources} argument, neocomplcache call {sources}.
		{sources} is name of source or list of sources name.
>
		inoremap <expr><Tab>  neocomplcache#start_manual_complete()
<
neocomplcache#manual_filename_complete()	*neocomplcache#manual_filename_complete()*
		Use this function on inoremap <expr>.  The keymapping call
		the file name completion of neocomplcache.  When you
		rearrange the file name completion of the Vim standard, you
		use it.
>
		inoremap <expr><C-x><C-f>  neocomplcache#manual_filename_complete()
<
neocomplcache#manual_omni_complete()		*neocomplcache#manual_omni_complete()*
		Use this function on inoremap <expr>.  The keymapping call
		the omni completion of neocomplcache.  When you rearrange
		the omni completion of the Vim standard, you use it.
>
		inoremap <expr><C-j>  neocomplcache#manual_filename_complete()
<
neocomplcache#manual_keyword_complete()		*neocomplcache#manual_keyword_complete()*
		Use this function on inoremap <expr>.  The keymapping call
		keyword completion of neocomplcache.  When you rearrange the
		keyword completion of the Vim standard, you use it.
>
		inoremap <expr><C-n>  pumvisible() ? "\<C-n>" : neocomplcache#manual_keyword_complete()

neocomplcache#close_popup()			*neocomplcache#close_popup()*
		Inset candidate and close popup menu for neocomplcache.
>
		inoremap <expr><C-y>  neocomplcache#close_popup()
<
neocomplcache#cancel_popup()			*neocomplcache#cancel_popup()*
		cancel completion menu for neocomplcache.
>
		inoremap <expr><C-e>  neocomplcache#cancel_popup()
<
neocomplcache#smart_close_popup()		*neocomplcache#smart_close_popup()*
		Inset candidate and close popup menu for neocomplcache.
		Unlike|neocomplcache#close_popup()|, this function changes
		behavior by|g:neocomplcache_enable_auto_select|smart.

neocomplcache#undo_completion()			*neocomplcache#undo_completion()*
		Use this function on inoremap <expr>. Undo inputed
		candidate.  Because there is not mechanism to cancel
		candidate in Vim, it will be convenient when it inflects.
>
		inoremap <expr><C-g>     neocomplcache#undo_completion()
<
neocomplcache#complete_common_string()		*neocomplcache#complete_common_string()*
		Use this function on inoremap <expr>. Complete common
		string in candidates. It will be convenient when candidates
		have long common string.
>
		inoremap <expr><C-l>     neocomplcache#complete_common_string()
<
<Plug>(neocomplcache_start_unite_complete)		*<Plug>(neocomplcache_start_unite_complete)*
		Start completion with |unite|.
		Note: Required unite.vim Latest ver.3.0 or above.

<Plug>(neocomplcache_start_unite_quick_match)		*<Plug>(neocomplcache_start_quick_match)*
		Start completion with |unite| and start quick match mode.
		Note: Required unite.vim Latest ver.3.0 or above.

==============================================================================
EXAMPLES					*neocomplcache-examples*
>
	"Note: This option must set it in .vimrc(_vimrc). NOT IN .gvimrc(_gvimrc)!
	" Disable AutoComplPop.
	let g:acp_enableAtStartup = 0
	" Use neocomplcache.
	let g:neocomplcache_enable_at_startup = 1
	" Use smartcase.
	let g:neocomplcache_enable_smart_case = 1
	" Use camel case completion.
	let g:neocomplcache_enable_camel_case_completion = 1
	" Use underbar completion.
	let g:neocomplcache_enable_underbar_completion = 1
	" Set minimum syntax keyword length.
	let g:neocomplcache_min_syntax_length = 3
	let g:neocomplcache_lock_buffer_name_pattern = '\*ku\*'
	
	" Define dictionary.
	let g:neocomplcache_dictionary_filetype_lists = {
	    \ 'default' : '',
	    \ 'vimshell' : $HOME.'/.vimshell_hist',
	    \ 'scheme' : $HOME.'/.gosh_completions'
	        \ }
	
	" Define keyword.
	if !exists('g:neocomplcache_keyword_patterns')
	    let g:neocomplcache_keyword_patterns = {}
	endif
	let g:neocomplcache_keyword_patterns['default'] = '\h\w*'
	
	" Plugin key-mappings.
	inoremap <expr><C-g>     neocomplcache#undo_completion()
	inoremap <expr><C-l>     neocomplcache#complete_common_string()
	
	" Recommended key-mappings.
	" <CR>: close popup and save indent.
	inoremap <expr><silent> <CR> <SID>my_cr_function()
	function! s:my_cr_function()
	  return pumvisible() ? neocomplcache#close_popup() . "\<CR>" : "\<CR>"
	endfunction
	" <TAB>: completion.
	inoremap <expr><TAB>  pumvisible() ? "\<C-n>" : "\<TAB>"
	" <C-h>, <BS>: close popup and delete backword char.
	inoremap <expr><C-h> neocomplcache#smart_close_popup()."\<C-h>"
	inoremap <expr><BS> neocomplcache#smart_close_popup()."\<C-h>"
	inoremap <expr><C-y>  neocomplcache#close_popup()
	inoremap <expr><C-e>  neocomplcache#cancel_popup()
	
	" For cursor moving in insert mode(Not recommended)
	"inoremap <expr><Left>  neocomplcache#close_popup() . "\<Left>"
	"inoremap <expr><Right> neocomplcache#close_popup() . "\<Right>"
	"inoremap <expr><Up>    neocomplcache#close_popup() . "\<Up>"
	"inoremap <expr><Down>  neocomplcache#close_popup() . "\<Down>"
	" Or set this.
	"let g:neocomplcache_enable_cursor_hold_i = 1
	" Or set this.
	"let g:neocomplcache_enable_insert_char_pre = 1
	
	" AutoComplPop like behavior.
	"let g:neocomplcache_enable_auto_select = 1
	
	" Shell like behavior(not recommended).
	"set completeopt+=longest
	"let g:neocomplcache_enable_auto_select = 1
	"let g:neocomplcache_disable_auto_complete = 1
	"inoremap <expr><TAB>  pumvisible() ? "\<Down>" : "\<C-x>\<C-u>"
	"inoremap <expr><CR>  neocomplcache#smart_close_popup() . "\<CR>"
	
	" Enable omni completion.
	autocmd FileType css setlocal omnifunc=csscomplete#CompleteCSS
	autocmd FileType html,markdown setlocal omnifunc=htmlcomplete#CompleteTags
	autocmd FileType javascript setlocal omnifunc=javascriptcomplete#CompleteJS
	autocmd FileType python setlocal omnifunc=pythoncomplete#Complete
	autocmd FileType xml setlocal omnifunc=xmlcomplete#CompleteTags
	
	" Enable heavy omni completion.
	if !exists('g:neocomplcache_omni_patterns')
	  let g:neocomplcache_omni_patterns = {}
	endif
	let g:neocomplcache_omni_patterns.ruby = '[^. *\t]\.\h\w*\|\h\w*::'
	"autocmd FileType ruby setlocal omnifunc=rubycomplete#Complete
	let g:neocomplcache_omni_patterns.php = '[^. \t]->\h\w*\|\h\w*::'
	let g:neocomplcache_omni_patterns.c = '[^.[:digit:] *\t]\%(\.\|->\)'
	let g:neocomplcache_omni_patterns.cpp = '[^.[:digit:] *\t]\%(\.\|->\)\|\h\w*::'
	
	" For perlomni.vim setting.
	" https://github.com/c9s/perlomni.vim
	let g:neocomplcache_omni_patterns.perl = '\h\w*->\h\w*\|\h\w*::'
<
==============================================================================
SOURCES						*neocomplcache-sources*

Neocomplcache reads automatically sources saved in an
autoload/neocomplcache/sources directory.

keyword_complete.vim				*keyword_complete*
		This source collects keywords from dictionaries... etc, and to
		use for completion.  Because the plugin offer the basic
		function of neocomplcache, neocomplcache does not work normally
		when you delete this plugin.

buffer_complete.vim				*buffer_complete*
		This source collects keywords from buffer.

member_complete.vim				*member_complete*
		This source collects use of member variables from buffer.

tags_complete.vim				*tags_complete*
		This source analyzes a tag file from tagfiles() for completion.
		When a huge tag file (above
		|g:neocomplcache_tags_caching_limit_file_size|) is set,
		neocomplcache don't make cache if you don't execute
		|:NeoComplCacheCachingTags|command.  Because tags_complete is
		too slow if tags_complete read a big tags file.  You should use
		more convenient include completion now.

syntax_complete.vim				*syntax_complete*
		This source analyzes a syntax file like
		autoload/syntaxcomplete.vim offered by default, and to
		add to candidate completion.  The plugin can recognize
		candidates a lot more than autoload/syntaxcomplete.vim.

include_complete.vim				*include_complete*
		This source will add the file which an opening buffer
		refers to to candidate.  It is convenient, because you do
		not need to prepare a tags file and a dictionary file.
		But it is necessary for 'path' and 'include',
		'includeexpr' to be set adequately. If vimproc is installed,
		neocomplcache will cache. But if not installed, auto caching
		feature is disabled. Please execute
		|:NeoComplCacheCachingInclude| manually.
 
vim_complete.vim				*vim_complete*
		This source analyzes context and start Omni completion of
		Vim script.  This plugin does not work other than editing
		time of Vim script.  I created it because neocomplcache
		cannot call |i_CTRL-X_CTRL-V|.  Local variable and a
		script variable, a function and the analysis of the
		command are implemented now.

dictionary_complete.vim				*dictionary_complete*
		This source adds candidates from 'dictionary' or
		|g:neocomplcache_dictionary_filetype_lists|.

filename_complete.vim				*filename_complete*
		This source collects filename candidates. It is useful
		when you input header file name.  It recognizes include
		pattern and include path like include_complete.

omni_complete.vim				*omni_complete*
		This source calls 'omnifunc' automatically when cursor
		text is matched with |g:neocomplcache_omni_patterns|. If
		|g:neocomplcache_omni_function_list|is defined,
		neocomplcache will give priority it.

abbrev_complete.vim				*abbrev_complete*
		This source collects candidates from abbrev.

------------------------------------------------------------------------------
USER SOURCES 					*neocomplcache-user-sources*

This section, introduce non default neocomplcache sources.

snippets_complete.vim				*neocomplcache-sources-snippets_complete*
		This source is for snippets completion.
		Note: This source is not in default sources after neocomplcache
		ver.7.0.
		https://github.com/Shougo/neocomplcache-snippets-complete

neco-ghc					*neocomplcache-sources-neco-ghc*
		https://github.com/ujihisa/neco-ghc
		eagletmt originally implemented and now ujihisa is maintaining
		this source.  It completes a source file written in Haskell.
		It requires ghc-mod <http://www.mew.org/~kazu/proj/ghc-mod/>.

neco-ruby					*neocomplcache-sources-neco-ruby*
		https://github.com/ujihisa/neco-ruby
		This source is for ruby completion.  Only require_relative
		completion is implemented so far.

==============================================================================
UNITE SOURCES					*neocomplcache-unite-sources*

						*neocomplcache-unite-source-neocomplcache*
neocomplcache
		Nominates neocomplcache completion candidates. The kind is "completion".
		This source is used in |<Plug>(neocomplcache_start_unite_complete)|.
>
		imap <C-k>  <Plug>(neocomplcache_start_unite_complete)
		imap <C-q>  <Plug>(neocomplcache_start_unite_quick_match)
<
==============================================================================
CREATE SOURCE					*neocomplcache-create-source*

In this clause, I comment on a method to make source of neocomplcache.  The
ability of neocomplcache will spread by creating source by yourself.

Todo

==============================================================================
FAQ						*neocomplcache-faq*

Q: Is there a way to control the colors used for popup menu using highlight
groups?:

A: Like this:
>
	highlight Pmenu ctermbg=8 guibg=#606060
	highlight PmenuSel ctermbg=1 guifg=#dddd00 guibg=#1f82cd
	highlight PmenuSbar ctermbg=0 guibg=#d6d6d6
<

Q: Python(or Ruby) interface crashes Vim using neocomplcache:

A: This is not neocomplcache issue. Please report to omnicomplete(rubycomplete
or pythoncomplete) and Vim interface maintainer.


Q: I like to move cursor by cursor keys. But neocomplcache popups menus...

A: Please set this in your .vimrc. But this feature requires Vim 7.3.418 or
above.
>
	let g:neocomplcache_enable_insert_char_pre = 1
<

Q: Where is snippets for neocomplcache?

A: https://github.com/Shougo/neocomplcache-snippets-complete

Q: To disable python omni complete in neocomplcache?:

A:
>
	let g:neocomplcache_omni_patterns['python'] = ''
<
Q: Can I enable quick match? :

A: Quick match feature is removed in latest neocomplcache.
Because quick match is hard to implement.
But you can use |unite.vim| to quick match.
>
	imap <expr> -  pumvisible() ?
	    \ "\<Plug>(neocomplcache_start_unite_quick_match)" : '-'
<
Q: How can i change the order of candidates? :

A: Please refer to g:neocomplcache_compare_function and
g:neocomplcache_source_rank.

Q: Input problem occurred in using uim-skk or other IME :

A: It may be fixed |g:neocomplcache_enable_prefetch| is 1.

==============================================================================
CHANGELOG					*neocomplcache-changelog*

2012-08-29
- Improved initialization.

2012-08-28
- Improved refresh behavior.
- Fixed neocomplcache#complete_common_string().

2012-08-25
- Deleted obsolute changelog.

2012-08-24
- Added FAQ item.
- Set refresh always.
- Change g:neocomplcache_enable_prefetch default value.

2012-08-23
- Fixed customlist completion problem.
- Added FAQ item.

2012-08-22
- Added :NeoComplCacheSetFileType command.
- Improved command-completion.
- Improved FAQ section.
- Improved context filetype.
- Updated features dict.
- Fixed g:neocomplcache_disable_auto_complete problem.

2012-08-21
- Updated vital.

2012-08-18
- Improved for iconv().

2012-08-14
- Fixed for vimshell.

2012-08-11
- Improved documentation.

2012-08-07
- Improved a bit.
- Fixed omni patterns for c and cpp.

2012-08-06
- Improved remove next keyword.
- Improved set context filetype.

2012-08-03
- Improved omni_complete.
- Added _ omnifunc.
- Deleted completefunc_complete source.
- Updated vital.

2012-08-02
- Fixed for g:neocomplcache_enable_insert_char_pre.
- Fixed omni_complete for compound filetype.
- Fixed dictionary_complete caching timing.

2012-08-01
- Fixed filename_complete.

2012-07-27
- Added FAQ section.
- Fixed skip filename patterns.

2012-07-26
- Fixed for g:neocomplcache_enable_insert_char_pre.
- Improved omni_complete source.

2012-07-24
- Fixed complete done error.

2012-07-23
- Added FAQ.

2012-07-22
- Updated examples.

2012-07-19
- Added FAQ section(I tired...).

2012-07-17
- Improved python interface check.

2012-07-15
- Fixed omni_complete.
- Fixed marker.

2012-07-11
- Check complete position.
- Fixed omni_complete error.
- Improved learning for Vim 7.3.598.

2012-07-08
- Improved omni_complete.

2012-07-06
- Improved buffer source.
- Supported python3.

2012-07-02
- Improved word caching behavior.

2012-06-28
- Fixed neocomplcache#is_plugin_locked() error.

2012-06-25
- Ignore document tags in tags_complete.

2012-06-23
- Improved error message.
- Improved filename escape.
- Fixed cache behavior.

2012-06-21
- Improved check_cache_list().
- Added g:neocomplcache_tags_caching_limit_file_size variable.

2012-06-10
- Improved same filetype for plaintex.

2012-06-07
- Fixed for tags_complete.

2012-06-06
- Fixed for fuzzyfinder.

2012-06-05
- Added g:neocomplcache_use_vimproc option.

2012-06-01
- Improved asynchronous cache behavior.

2012-05-31
- Improved MacOS check.
- Fixed for css omni_complete.

2012-05-30
- Fixed for MacVim check.

2012-05-28
- Fixed for MacVim.

2012-05-26
- Fixed omni_complete for rubycomplete.
- Fixed for eskk convertion check.
- Improved check lock.
- Improved for omni_complete.

2012-05-24
- Changed filename_complete default rank.
- Improved auto complete behavior.

2012-05-23
- Improved sort behavior.
- Fixed omni_complete sort.

2012-05-22
- Added word order function.

2012-05-21
- Fixed warning mappings.
- Silent mapping.
- Improved g:neocomplcache_source_rank documentaion.

2012-05-20
- Fixed g:neocomplcache_enable_prefetch initialization.
- Added neocomplcache#complete_check().
- Improved complete_check timing.

2012-05-19
- Fixed for eskk error.
- Supported Vim 7.3.519 feature.
- Improved error catch behavior.
- Deleted fileencoding.
- Supported wildcard import in include_complete.
- Fixed filename_complete.

2012-05-18
- Fixed filename completion.

2012-05-14
- Deleted debug message.
- Fixed error in Vim 7.2.

2012-05-11
- Improved buffer cache behavior.
- Fixed include filename completion.

2012-05-09
- Refactored cache.vim.
- Fixed tags_complete problem.
- Improved asynchronous cache.
- Improved cache timing.

2012-05-08
- Fixed cd problem.
- Ver.7.1 development is started.

------------------------------------------------------------------------------
ChangeLog neocomplcache 7.0:

2012-05-04
- Fixed command definition.
- Ver.7.0.

2012-05-03
- Improved make cache behavior.

2012-05-02
- Updated examples.
- Added g:neocomplcache_lock_iminsert option.

2012-04-28
- Updated vital.

2012-04-24
- Fixed make cache bug.

2012-04-22
- Improved member_complete behavior.
- Improved buffer_complete behavior.
- Improved omni_complete behavior.

2012-04-20
- Fixed feedkeys() problem.

2012-04-10
- Improved escape filename.
- Improved sudo check.

2012-04-05
- Improved cache event.

2012-04-02
- Improved documentation.
- Fixed asyncronous cache bug.

2012-03-31
- Changed g:neocomplcache_enable_prefetch default value.
- Improved asyncronous caching check timing.
- Fixed caching.
- Supported Ctrl-x mode fix.

2012-03-27
- Fixed g:neocomplcache_enable_fuzzy_completion documentaion.
- Added g:neocomplcache_fuzzy_completion_start_length option.

2012-03-26
- Fixed filename escape.
- Fixed vim keyword pattern.

2012-03-25
- Fixed filename_complete behavior.

2012-03-23
- Fixed g:neocomplcache_enable_cursor_hold_i behavior.

2012-03-21
- Improved filename pattern.

2012-03-15
- Fixed get_cur_text().

2012-03-13
- Fixed vb keyword pattern.

2012-03-10
- Fixed cur_text bug.

2012-03-07
- Fixed bell problem.
- Deleted snippet source.
- Fixed get_cur_text().
- Improved completion source.
- Updated vital.

2012-03-06
- Fixed Vim search.
- Improved temporary directory behavior.

2012-03-05
- Fixed asynchronous load.
- Fixed expand().
- Improved version check.
- Enabled beep.
- Improved cache behavior.

2012-03-04
- Improved filename escape.
- Improved asyncronous caching behavior.

2012-03-03
- Fixed temporary directory initialization.

2012-02-24
- Improved auto caching.
- Fixed filetype error in dictionary_complete source.

2012-02-23
- Improved :NeoComplCacheToggle behavior.
- Updated vital.

2012-02-22
- Updated vital.

2012-02-20
- Fixed for g:neocomplcache_enable_prefetch default value.

2012-02-17
- Improved context filetype.

2012-02-16
- Changed g:neocomplcache_manual_completion_start_length default value.
- Fixed abbr error in vim_complete source.
- Improved filter behavior.

2012-02-15
- Improved snippets_complete changes description.
- Warning if using obsolute mappings.
- Check device file in filename_complete.

2012-02-14
- Improved helper function.

2012-02-12
- Deleted vimshell omni fuction pattern.

2012-02-11
- Fixed on_insert_enter().
- Fixed cur_text check.
- Fixed completion bug.
- Improved omnifunc error detection.
- Refactored is_windows.

2012-02-10
- Improved g:neocomplcache_cursor_hold_i_time behavior.
- Improved Vim version check.
- Added g:neocomplcache_enable_insert_char_pre option.
- Do not set refresh key.

2012-02-08
- Improved fuzzy completion behavior.

2012-02-06
- Improved buffer_complete.
- Fixed save cache error.

2012-02-05
- Improved include_complete.
- Fixed buffer_complete cache problem.
- Fixed documentaion.
- Fixed changed buffer problem.

2012-02-04
- Renamed g:neocomplcache_plugin_disable as g:neocomplcache_source_disable.
- Renamed g:neocomplcache_plugin_rank as g:neocomplcache_source_rank.
- Renamed g:neocomplcache_plugin_completion_length as g:neocomplcache_source_completion_length.
- Revised documentation.
- Added :NeoComplCacheLockSource and :NeoComplCacheUnLockSource commands.
- Renamed g:neocomplcache_filetype_include_lists as g:neocomplcache_context_filetype_lists.
- Added g:neocomplcache_release_cache_time option.
- Implemented release cache in include_complete.
- Deleted local var_dictionary completion in vim_complete.

2012-02-02
- Ver.7.0 development is started.
- Splited snippets_complete.
- Deleted Japanese documentation.
- Improved documentation.

==============================================================================
vim:tw=78:ts=8:ft=help:norl:noet:fen:fdl=0:noet:
