*omnicppcomplete.txt*   Last Change: 25 juin 2006       Omnicompletion for C++


*omnicppcomplete*

Author: Vissale NEANG (fromtonrouge AT gmail DOT com)

OmniCppComplete version 0.4

For Vim version 7.0 and above

==============================================================================

1. Overview                                     |omnicpp-overview|
2. Downloads                                    |omnicpp-download|
3. Installation                                 |omnicpp-installation|
4. Options                                      |omnicpp-options|
5. Features                                     |omnicpp-features|
6. Limitations                                  |omnicpp-limitations|
7. History                                      |omnicpp-history|
8. Thanks                                       |omnicpp-thanks|

==============================================================================
1. Overview~
                                                *omnicpp-overview*
The purpose of this script is to provide an 'omnifunc' function for the C++
language. In a C++ file, while in insert mode, you can use CTRL-X CTRL-O to:

        * Complete namespaces, classes, structs and unions
        * Complete attribute members and return type of functions
        * Complete the "this" pointer
        * Complete an object after a cast (C and C++ cast)
        * Complete typedefs and anonymous types

You can set a "may complete" behaviour to start a completion automatically
after a '.', '->' or '::'. Please see |omnicpp-may-complete| for more details.

The script needs an |Exuberant_ctags| database to work properly.

==============================================================================
2. Downloads~
                                                *omnicpp-download*
You can download the latest release of the script from this url :

        http://www.vim.org/scripts/script.php?script_id=1520

You can download |Exuberant_ctags| from :

        http://ctags.sourceforge.net

==============================================================================
3. Installation~
                                                *omnicpp-installation*
3.1. Script installation~

Unzip the downloaded file in your personal |vimfiles| directory (~/.vim under 
unix or %HOMEPATH%\vimfiles under windows). The 'omnifunc' will be 
automatically set for C++ files.

You also have to enable plugins by adding these two lines in your|.vimrc|file: >

        set nocp
        filetype plugin on
<
Please see |cp| and |filetype-plugin-on| sections for more details.

3.1.1. Files~

After installation you should find these files :

    after\ftplugin\cpp.vim

    autoload\omni\common\debug.vim
                        \utils.vim

    autoload\omni\cpp\complete.vim
                     \includes.vim
                     \items.vim
                     \maycomplete.vim
                     \namespaces.vim
                     \settings.vim
                     \tokenizer.vim
                     \utils.vim

    doc\omnicppcomplete.txt

3.2. Building the Exuberant Ctags database~

To extract C++ symbols informations, the script needs an |Exuberant_ctags|
database.

You have to build your database with at least the following options:
        --c++-kinds=+p  : Adds prototypes in the database for C++ files.
        --fields=+iaS   : Adds inheritance (i), access (a) and function 
                          signatures (S) informations.
        --extra=+q      : Adds context to the tag name. Note: Without this
                          option, the script cannot get class members.

Thus to build recursively a ctags database from the current directory, the
command looks like this:
>
        ctags -R --c++-kinds=+p --fields=+iaS --extra=+q .
<
You can add a map in your |.vimrc| file, eg: >

        map <C-F12> :!ctags -R --c++-kinds=+p --fields=+iaS --extra=+q .<CR>
<
Or you can add these options in your ctags config file (~/.ctags under unix or
%HOMEPATH%\ctags.cnf under windows) and execute the command : >

        :!ctags -R .
<
If your project contains files of other languages you may add the following
options:
        --languages=c++ : Builds only the tags for C++ files.

If your project contains macros you may also use the -I option.

Please read the ctags help or ctags man page for more details.

3.3. Setting the 'tags' option~

The default value of the option 'tags' is "./tags,tags" ("./tags,./TAGS,tags,TAGS"
when |+emacs_tags| is enabled), if you build your tag database with the cmd above,
you normally don't have to change this setting (The cmd used above generates a 
file with the name "tags"). In this case your current working directory must be 
the directory where the tags file reside.

Note:   When |+emacs_tags| is enabled, the script may display members twice, it's 
        recommended to set tags to "./tags,tags' or "./TAGS,TAGS".

If your tags file is not named "tags" you have to add it in the 'tags'
option eg: >

        set tags+=/usr/tagsdir/mytagfile       
<
You can ensure that the 'tags' option is set properly by executing the following
command: >

        :tselect MyClass
<
Where MyClass is a class of your project. This command should display all 
possible tags for the type MyClass.

3.4. Simple test~

Now you can do a simple test. Edit a C++ file and write the simplest case : >

        MyClass myObject;
        myObject.<C-X><C-O>
<
You should see class members of MyClass.

==============================================================================
4. Options~
                                                *omnicpp-options*

You can change completion behaviour by setting script options in your |.vimrc|
configuration file.

4.1. Global scope search toggle~
                                        *OmniCpp_GlobalScopeSearch*

You can enable/disable the global scope search by setting the
OmniCpp_GlobalScopeSearch option.

Possible values are : 
        0 = disabled
        1 = enabled
        [default=1] >

        let OmniCpp_GlobalScopeSearch = 1
<        
4.2. Namespace search method~
                                        *OmniCpp_NamespaceSearch*

You can change the 'using namespace' search behaviour by setting the
OmniCpp_NamespaceSearch option.

Possible values are :
        0 = namespaces disabled
        1 = search namespaces in the current buffer
        2 = search namespaces in the current buffer and in included files
        [default=1] >
        
        let OmniCpp_NamespaceSearch = 1
<
When OmniCpp_NamespaceSearch is 2, "using namespace" declarations are parsed
in the current buffer and also in included files. To find included files, the
script use the vim env 'path', so you have to set it properly.

Note: included files are searched with lvimgrep, thus the location list of the
current window is changed.

Note: When the 'filetype' is "c", namespace search is always disabled even if
OmniCpp_NamespaceSearch != 0

4.3. Class scope completion mode~
                                        *OmniCpp_DisplayMode*

When you are completing a class scope (eg: MyClass::<C-X><C-O>), depending on
the current scope, you may see sometimes static, public, protected or private
members and sometimes you may see all members. By default the choice is done 
automatically by the script but you can override it with the 
OmniCpp_DisplayMode option.

Note: This option can be use when you have friend classes in your project (the 
script does not support friend classes).

Possible values are :
        0 = auto
        1 = always show all members
        [default=0] >

        let OmniCpp_DisplayMode = 0
<
4.4. Show scope in abbreviation~
                                        *OmniCpp_ShowScopeInAbbr*

By default, in the |omnicpp-popup| menu, you will see the scope of a match in 
the last column. You can remove this column and add the scope at the beginning
of match abbreviation.
eg: 

OmniCpp_ShowScopeInAbbr = 0
        +-------------------------------------+
        |method1(   f  +  MyNamespace::MyClass|
        |_member1   m  +  MyNamespace::MyClass|
        |_member2   m  #  MyNamespace::MyClass|
        |_member3   m  -  MyNamespace::MyClass|
        +-------------------------------------+

OmniCpp_ShowScopeInAbbr = 1
        +-------------------------------------+
        |MyNamespace::MyClass::method1(   f + |
        |MyNamespace::MyClass::_member1   m + |
        |MyNamespace::MyClass::_member2   m # |
        |MyNamespace::MyClass::_member3   m - |
        +-------------------------------------+

Possible values are :
        0 = don't show scope in abbreviation
        1 = show scope in abbreviation and remove the last column
        [default=0] >

        let OmniCpp_ShowScopeInAbbr = 0
<
4.5. Show prototype in abbreviation~
                                        *OmniCpp_ShowPrototypeInAbbr*

This option allows to display the prototype of a function in the abbreviation
part of the popup menu.

Possible values are:
        0 = don't display prototype in abbreviation
        1 = display prototype in abbreviation
        [default=0] >
        
        let OmniCpp_ShowPrototypeInAbbr = 0
<
4.6. Show access~
                                        *OmniCpp_ShowAccess*

This option allows to show/hide the access information ('+', '#', '-') in the 
popup menu.

Possible values are:
        0 = hide access
        1 = show access
        [default=1] >
        
        let OmniCpp_ShowAccess = 1

4.7. Default using namespace list~
                                        *OmniCpp_DefaultNamespaces*

When |OmniCpp_NamespaceSearch| is not 0, the script will parse using namespace
declarations in the current buffer and maybe in included files.
You can specify manually a default namespace list if you want with the
OmniCpp_DefaultNamespaces option. Each item in the list is a namespace name.
eg: If you have

        let OmniCpp_DefaultNamespaces = ["std", "MyNamespace"]

    It will be the same as inserting this declarations at the top of the
    current buffer :

        using namespace std;
        using namespace MyNamespace;

This option can be use if you don't want to parse using namespace declarations
in included files and want to add namespaces that are always used in your
project.

Possible values are : 
        List of String
        [default=[]] >

        let OmniCpp_DefaultNamespaces = []
<
4.8.    May complete behaviour~
                                        *omnicpp-may-complete*

This feature allows you to run automatically a completion after a '.', '->' 
or '::'. By default, the "may complete" feature is set automatically for '.' 
and '->'. The reason to not set this feature for the scope operator '::' is 
sometimes you don't want to complete a namespace that contains many members.

To enable/disable the "may complete" behaviour for dot, arrow and scope
operator, you can change the option OmniCpp_MayCompleteDot,
OmniCpp_MayCompleteArrow and OmniCpp_MayCompleteScope respectively.

                                        *OmniCpp_MayCompleteDot*
Possible values are :
        0 = May complete disabled for dot
        1 = May complete enabled for dot
        [default=1] >

        let OmniCpp_MayCompleteDot = 1
<
                                        *OmniCpp_MayCompleteArrow*
Possible values are :
        0 = May complete disabled for arrow
        1 = May complete enabled for arrow
        [default=1] >

        let OmniCpp_MayCompleteArrow = 1
<
                                        *OmniCpp_MayCompleteScope*
Possible values are :
        0 = May complete disabled for scope
        1 = May complete enabled for scope
        [default=0] >

        let OmniCpp_MayCompleteScope = 0
<

Note: You can obviously continue to use <C-X><C-O>

4.9. Select/Don't select first popup item~
                                        *OmniCpp_SelectFirstItem*

Note: This option is only used when 'completeopt' does not contain "longest".

When 'completeopt' does not contain "longest", Vim automatically select the
first entry of the popup menu. You can change this behaviour with the
OmniCpp_SelectFirstItem option.

Possible values are:
        0 = don't select first popup item
        1 = select first popup item
        [default=0] >
        
        let OmniCpp_SelectFirstItem = 0


==============================================================================
5. Features~
                                                *omnicpp-features*
5.1.  Popup menu~
                                                *omnicpp-popup*
Popup menu format:
        +-------------------------------------+
        |method1(   f  +  MyNamespace::MyClass|
        |_member1   m  +  MyNamespace::MyClass|
        |_member2   m  #  MyNamespace::MyClass|
        |_member3   m  -  MyNamespace::MyClass|
        +-------------------------------------+
            ^       ^  ^          ^
           (1)     (2)(3)        (4)

(1) name of the symbol, when a match ends with '(' it's a function.

(2) kind of the symbol, possible kinds are :
        * c = classes
        * d = macro definitions
        * e = enumerators (values inside an enumeration)
        * f = function definitions
        * g = enumeration names
        * m = class, struct, and union members
        * n = namespaces
        * p = function prototypes
        * s = structure names
        * t = typedefs
        * u = union names
        * v = variable definitions

(3) access, possible values are :
        * + = public
        * # = protected
        * - = private
Note: enumerators have no access information

(4) scope where the symbol is defined.
Note: If the scope is empty it's a global symbol
Note: anonymous scope may end with  __anon[number]
eg: If you have an anonymous enum in MyNamespace::MyClass : >

        namespace MyNamespace
        {
            class MyClass
            {
                private:

                enum
                {
                    E_ENUM0,
                    E_ENUM1,
                    E_ENUM2
                };
            };
        }
<

You should see :

        +----------------------------------------------+
        |E_ENUM0    e     MyNamespace::MyClass::__anon1|
        |E_ENUM1    e     MyNamespace::MyClass::__anon1|
        |E_ENUM2    e     MyNamespace::MyClass::__anon1|
        +----------------------------------------------+
                                                   ^
                                              __anon[number]

5.2.  Global scope completion~

The global scope completion allows you to complete global symbols for the base 
you are currently typing. The base can start with '::' or not.
Note: Global scope completion only works with a non empty base, if you run a
completion just after a '::' the completion will fail. The reason is that if
there is no base to complete the script will try to display all the tags in
the database. For small project it could be not a problem but for others you
may wait 5 minutes or more for a result.

eg1 : >

        pthread_cr<C-X><C-O>    =>      pthread_create
<
Where pthread_create is a global function.
eg2: >
        ::globa<C-X><C-O>       =>     ::global_func(
                                        +----------------+
                                        |global_func(   f|
                                        |global_var1    v|
                                        |global_var2    v|
                                        +----------------+
<
Where global_var1, global_var2 and global_func are global symbols
eg3: >
        ::<C-X><C-O>            =>      [NO MATCH]
<
No match because a global completion from an empty base is not allowed.

5.3.  Namespace scope completion~

You can complete namespace members after a 'MyNamespace::'. Contrary to global
scope completion you can run a completion from an empty base.
Possible members are:
        * Namespaces
        * Classes
        * Structs
        * Unions
        * Enums
        * Functions
        * Variables
        * Typedefs

eg: >
        MyNamespace::<C-X><C-O>
                    +--------------------------------+
                    |E_ENUM0            e MyNamespace|
                    |E_ENUM1            e MyNamespace|
                    |E_ENUM2            e MyNamespace|
                    |MyClass            c MyNamespace|
                    |MyEnum             g MyNamespace|
                    |MyStruct           s MyNamespace|
                    |MyUnion            u MyNamespace|
                    |SubNamespace       n MyNamespace|
                    |doSomething(       f MyNamespace|
                    |myVar              v MyNamespace|
                    |something_t        t MyNamespace|
                    +--------------------------------+

5.4.  Class scope completion~

You can complete class members after a 'MyClass::'. Contrary to global scope
completion you can run a completion from an empty base.
By default, there is two behaviours for class scope completion.

        a) Completion of a base class of the current class scope

        When you are completing a base class of the current class scope, you
        will see all members of this class in the popup menu.
        eg: >

        class A
        {
        public:
            enum
            {
                E_ENUM0,
                E_ENUM1,
                E_ENUM2,
            };

            void func1();
            static int _staticMember;
            
        private:
            int _member;
        };

        class B : public A
        {
        public:
            void doSomething();
        };


        void MyClassB::doSomething()
        {
            MyClassA::<C-X><C-O>
                     +---------------------------+
                     |E_ENUM0        e   MyClassA|
                     |E_ENUM1        e   MyClassA|
                     |E_ENUM2        e   MyClassA|
                     |func1(         f + MyClassA|
                     |_member        m - MyClassA|
                     |_staticMember  m + MyClassA|
                     +---------------------------+
        }
<

        b) Completion of a non base class of the current class scope

        When you are completing a class that is not a base class of the
        current class you will see only enumerators and static members.
        eg: >

        class C
        {
        public:
            void doSomething();
        };

        void MyClassC::doSomething()
        {
            MyClassA::<C-X><C-O>
                     +---------------------------+
                     |E_ENUM0        e   MyClassA|
                     |E_ENUM1        e   MyClassA|
                     |E_ENUM2        e   MyClassA|
                     |_staticMember  m + MyClassA|
                     +---------------------------+
        }
<
You can override the default behaviour by setting the
|OmniCpp_DisplayMode| option.

5.5.  Current scope completion~

When you start a completion from an empty instruction you are in "Current
scope completion" mode. You will see possible members of each context in 
the context stack.
eg: >
        void MyClass::doSomething()
        {
            using namespace MyNamespace;
            using namespace SubNamespace;

            // You will see members of each context in the context stack
            // 1) MyClass members
            // 2) MyNamespace::SubNamespace members
            // 3) MyNamespace members

            <C-X><C-O>
            +------------------------------------------+
            |_member1     m + MyClass                  |
            |_member2     m # MyClass                  |
            |func1(       f   MyNamespace::SubNamespace|
            |var          v   MyNamespace::SubNamespace|
            |func1(       f   MyNamespace              |
            |var          v   MyNamespace              |
            +------------------------------------------+
        }
<

5.6.  Class, Struct and Union members completion~

You can complete members of class, struct and union instances after a '->' or
'.'.
eg: >
        MyClass myObject;
        myObject.<C-X><C-O>
                +-----------------------+
                |_member1   m + MyClass |
                |_member2   m # MyClass |
                +-----------------------+
<

5.7.  Attribute members and returned type completion~

You can complete a class member or a return type of a function.
eg: >
        MyClass myObject;

        // Completion of the member _member1
        myObject._member1-><C-X><C-O>
                          +------------------------+
                          |get(   m + AnotherClass1|
                          +------------------------+

        // Completion of the return type of the function get()
        myObject._member1->get()-><C-X><C-O>
                                 +--------------------------+
                                 |_member1 m + AnotherClass2|
                                 |_member2 m # AnotherClass2|
                                 |_member3 m - AnotherClass2|
                                 +--------------------------+

5.8.  Anonymous type completion~

Note: To use this feature you need at least|Exuberant_ctags| version 5.6

You can complete an anonymous type like this : >
        struct
        {
            int a;
            int b;
            int c;
        }globalVar;

        void func()
        {
            globalVar.<C-X><C-O>
                     +---------------+
                     |a   m + __anon1|
                     |b   m + __anon1|
                     |c   m + __anon1|
                     +---------------+
        }
<
Where globalVar is a global variable of an anonymous type

5.9.  Typedef completion~

You can complete a typedef. The typedef is resolved recursively, thus typedef
of typedef of... may not be a problem.

You can also complete a typedef of an anonymous type, eg : >
        typedef struct
        {
            int a;
            int b;
            int c;
        }something_t;

        something_t globalVar;

        void func()
        {
            globalVar.<C-X><C-O>
                     +---------------+
                     |a   m + __anon1|
                     |b   m + __anon1|
                     |c   m + __anon1|
                     +---------------+
        }
<
Where globalVar is a global variable of typedef of an anonymous type.

5.10. Completion of the "this" pointer~

You can complete the "this" pointer.
eg: >
        this-><C-X><C-O>
             +-----------------------+
             |_member1   m + MyClass |
             |_member2   m # MyClass |
             +-----------------------+

        (*this).<C-X><C-O>
               +-----------------------+
               |_member1   m + MyClass |
               |_member2   m # MyClass |
               +-----------------------+
<

5.11.  Completion after a cast~

You can complete an object after a C or C++ cast.
eg: >
        // C cast style
        ((AnotherStruct*)pStruct)-><C-X><C-O>

        // C++ cast style
        static_cast<AnotherStruct*>(pStruct)-><C-X><C-O>
<

5.12. Preview window~

If the 'completeopt' option contains the setting "preview" (this is the 
default value), you will see a preview window during the completion.
This window shows useful informations like function signature, filename where
the symbol is define etc...

The preview window contains tag informations, the list below is non exhaustive.

        * name : name of the tag
        * cmd : regexp or line number that helps to find the tag 
        * signature : signature for prototypes and functions
        * kind : kind of the tag (eg: namespace, class etc...)
        * access : access information (eg: public, protected, private)
        * inherits : list of base classes
        * filename : filename where the tag is define

5.13. Code tokenization~

When you start a completion, the current instruction is tokenized ignoring
spaces, tabs, carriage returns and comments. Thus you can complete a symbol
even if the current instruction is on multiple lines, has comments between
words etc... :
eg: this case is unrealistic but it's just for illustration >

        myObject   [ 0 ]/* Why is there a comment here ?*/
        ->_member
                ->      <C-X><C-O>
<

==============================================================================
6. Limitations~
                                                *omnicpp-limitations*
Some C++ features are not supported by the script, some implemented features
may not work properly in some conditions. They are multiple reasons like a
lack of informations in the database, performance issues and so on...

6.1. Attribute members and returned type completion~

To work properly, the completion of attribute members and returned type of
functions depends on how you write your code in the class declaration.
Because the tags database does not contain information like return type or
type of a member, the script use the cmd information of the tag to determine
the type of an attribute member or the return type of a function.

Thus, because the cmd is a regular expression (or line number for #define) if
you write your code like this : >

        class MyClass
        {
            public:
            
            MyOtherClass
            _member;
        };
<
The type of _member will not be recognized, because the cmd will be 
/^    _member;$/ and does not contain the type MyOtherClass.
The correct case should be : >

        class MyClass
        {
            public:
            
            MyOtherClass _member;
        };
<
It's the same problem for return type of function : >

        class MyClass
        {
            public:
            
            MyOtherClass
            getOtherClass(); 
        };
<
Here the cmd will be /^    getOtherClass();$/ and the script won't find the
return type.
The correct case should be : >
        class MyClass
        {
            public:
            
            MyOtherClass getOtherClass(); 
        };
<

6.2. Static members~

It's the same problem as above, tags database does not contain informations
about static members. The only fast way to get this information is to use the
cmd.

6.3. Typedef~

It's the same problem as above, tags database does not contain informations
about the type of a typedef. The script use the cmd information to resolve the
typedef.

6.4. Restricted inheritance access~

Tags database contains inheritance informations but unfortunately inheritance 
access are not available. We could use the cmd but we often find code
indentation like this : >
        
        class A :
                public B,
                protected C,
                private D
        {
        };
<
Here the cmd will be /^class A :$/, we can't extract inheritance access.

6.5. Using namespace parsing~

When you start a completion, using namespace declarations are parsed from the
cursor position to the first scope to detect local using namespace 
declarations. After that, global using namespace declarations are parsed in the
file and included files.

There is a limitation for global using namespace detection, for performance
issues only using namespace that starts a line will be detected.

6.6. Friend classes~

Tags database does not contain informations about friend classes. The script
does not support friend classes.

6.7. Templates~

At the moment, |Exuberant_ctags| does not provide additional informations for
templates. That's why the script does not handle templates.

==============================================================================
7. History~

Version 0.4
   -   The script is renamed to OmniCppComplete according to the library
       script directory structure.        
   -   OmniCpp_ClassScopeCompletionMethod renamed to OmniCpp_DisplayMode
   -   Fixed a bug where the quickfix list is modified after a completion.
   -   OmniCpp_ShowPrototypeInAbbr option added. It allows to show the
       function signature in the abbreviation.
   -   OmniCpp_ShowAccess option added. It allows to hide the access
       information in the popup menu.
   -   The tags database format must be a ctags 5.6 database if you want to 
       complete anonymous types.
   -   Fixed current scope detection not working properly in destructors.
   -   Don't show protected and private members according to the current scope. 
   -   Overloaded functions are now filtered properly.
   -   New cache system using less memory.
   -   The class scope of a method is now resolved properly with "using
       namespace" declarations.
   -   OmniCpp_SelectFirstItem option added. It allows to not select the first
       item in the popup menu when 'completeopt' does not contain "longest".
   -   Fixed the bug where a "random" item in the popup menu is selected
       by default when 'completeopt' does not contain "longest" option.
   -   The script is now split in library scripts.
   -   Cache added for 'using namespace' search in included files
   -   Default value for OmniCpp_NamespaceSearch is now 1 (search only in the
       current buffer).
   -   Namespace search automatically disabled for C files even if 
       OmniCpp_NamespaceSearch != 0.
   -   To avoid linear search in tags files, the ignorecase option is now 
       disabled when getting tags datas (the user setting is restored after).
   -   Fixed a bug where friend functions may crash the script and also crash vim.

Version 0.32
   -   Optimizations in search members methods.
   -   'May complete' behaviour is now set to default for dot '.' and arrow
       '->' (mappings are set in after/ftplugin/cpp.vim)
   -   Fixed the option CppOmni_ShowScopeInAbbr not detected after the first
       completion.
   -   Exceptions catched from taglist() when a tag file is corrupted.
   -   Fixed a bug where enumerators in global scope didn't appear in the
       popup menu.

Version 0.31
   WARNING: For this release and future releases you have to build your tags 
       database with this cmd :
       "ctags -R --c++-kinds=+p --fields=+iaS --extra=+q ."
       Please read installation instructions in the documentation for details

   -   May complete added, please see installation notes for details.
   -   Fixed a bug where the completion works while in a comment or in a string.

Version 0.3
   WARNING: For this release and future releases you have to build your tags 
       database with this cmd :
       "ctags -R --c++-kinds=+p --fields=+iaS --extra=+q ."
       Please read installation instructions in the documentation for details

   -   Documentation added.
   -   Fixed a bug where typedefs were not correctly resolved in namespaces
       in some cases.
   -   Fixed a bug where the type can not be detected when we have a decl
       like this: class A {}globalVar;
   -   Fixed a bug in type detection where searchdecl() (gd) find
       incorrect declaration instruction.
   -   Global scope completion now only works with non-empty base. 
   -   Using namespace list is now parsed in the current buffer and in
       included files.
   -   Fixed a bug where the completion fails in some cases when the user
       sets the ignorecase to on
   -   Preview window informations added
   -   Some improvements in type detection, the type can be properly detected
       with a declaration like this:
       'Class1 *class1A = NULL, **class1B = NULL, class1C[9], class1D[1] = {};'
   -   Fixed a bug where parent scopes were not displayed in the popup menu 
       in the current scope completion mode.
   -   Fixed a bug where an error message was displayed when the last
       instruction was not finished.
   -   Fixed a bug where the completion fails if a punctuator or operator was
       immediately after the cursor.
   -   The script can now detect parent contexts at the cursor position 
       thanks to 'using namespace' declarations.
       It can also detect ambiguous namespaces. They are not included in 
       the context list.
   -   Fixed a bug where the current scope is not properly detected when
       a file starts with a comment
   -   Fixed a bug where the type is not detected when we have myObject[0]
   -   Removed the system() call in SearchMembers(), no more calls to the
       ctags binary. The user have to build correctly his database with the cmd:
       "ctags -R --c++-kinds=+p --fields=+iaS --extra=+q ."
   -   File time cache removed, the user have to rebuild his data base after a
       modification.

Version 0.22
   -   Completion of unnamed type (eg: You can complete g_Var defined like
       this 'struct {int a; int b;}g_Var;'). It also works for a typedef of
       an unnamed type (eg: 'typedef struct {int a; int b;}t_mytype; t_mytype
       g_Var;').
   -   Tag file's time cache added, if a tag file has changed the global
       scope result cache is cleared.
   -   Fixed a bug where the tokenization process enter in an infinite loop
       when a file starts with '/*'.

Version 0.21
   -   Improvements on the global scope completion.
       The user can now see the progression of the search and complete
       matches are stored in a cache for optimization. The cache is cleared
       when the tag env is modified.
   -   Within a class scope when the user complete an empty word, the popup
       menu displays the members of the class then members of the global
       scope.
   -   Fixed a bug where a current scope completion failed after a punctuator
       or operator (eg: after a '=' or '!=').

Version 0.2
   -   Improvements in type detection (eg: when a variable is declared in a
       parameter list, a catch clause, etc...)
   -   Code tokenization => ignoring spaces, tabs, carriage returns and comments
       You can complete a code even if the instruction has bad
       indentation, spaces or carriage returns between words
   -   Completion of class members added
   -   Detection of the current scope at the cursor position.
       If you run a completion from en empty line, members of the current
       scope are displayed. It works on the global namespace and the current
       class scope (but there is not the combination of the 2 for the moment)
   -   Basic completion on the global namespace (very slow)
   -   Completion of returned type added
   -   this pointer completion added
   -   Completion after a cast added (C and C++ cast)
   -   Fixed a bug where the matches of the complete menu are not filtered
       according to what the user typed
   -   Change the output of the popup menu. The type of the member
       (function, member, enum etc...) is now display as a single letter.
       The access information is display like this : '+' for a public member
       '#' for a protected member and '-' for a private member.
       The last information is the class, namespace or enum where the member is define.

Version 0.12:
   -   Complete check added to the search process, you can now cancel
       the search during a complete search.
   
Version 0.1:
   -   First release

==============================================================================
8. Thanks~
        * For help, documentation, bug report :
                Arthur Axel "fREW" Schmidt      (documentation)
                Dennis Lubert                   (bugs)
                Markus Trenkwalder              (bugs)
                Martin Stubenschrott            (bugs)
                Robert Webb                     (bugs)
            
        * Darren Hiebert for Exuberant Ctags

        * All Vim devs for Vim
        
        * Bram Moolenaar for Vim
        
        * You for using this script :)

==============================================================================

 vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl:
