items.vim

vim的自动配置文件

function! s:GetTypeInfoOfVariable(contextStack, szVariable, bSearchDecl)
    let result = {}

    if a:bSearchDecl
        " Search type of declaration
        "let result = s:SearchTypeInfoOfDecl(a:szVariable)
        let result = s:SearchDecl(a:szVariable)
    endif

    if result=={}
        let szFilter = "index(['m', 'v'], v:val.kind[0])>=0"
        let tagItem = s:ResolveSymbol(a:contextStack, a:szVariable, szFilter)
        if tagItem=={}
            return result
        endif
        if has_key(tagItem, 'typeref')
            " Maybe the variable is a global var of an
            " unnamed class, struct or union.
            " eg:
            " 1)
            " struct
            " {
            " }gVariable;
            " In this case we need the tags (the patched version)
            " Note: We can have a named type like this:
            " 2)
            " class A
            " {
            " }gVariable;
            if s:IsUnnamedType(tagItem)
                " It's an unnamed type we are in the case 1)
                let result = omni#cpp#utils#CreateTypeInfo(tagItem)
            else
                " It's not an unnamed type we are in the case 2)
                let result = omni#cpp#utils#CreateTypeInfo(substitute(tagItem.typeref, '\w\+:', '', 'g'))
            endif
        else
            let szCmdWithoutVariable = substitute(omni#cpp#utils#ExtractCmdFromTagItem(tagItem), '\C\<'.a:szVariable.'\>.*', '', 'g')
            let tokens = omni#cpp#tokenizer#Tokenize(omni#cpp#utils#GetCodeFromLine(szCmdWithoutVariable))
            let result = omni#cpp#utils#CreateTypeInfo(omni#cpp#utils#ExtractTypeInfoFromTokens(tokens))
            " TODO: Namespace resolution for result
        endif
    endif

    return result
endfunc

" Get the type info string from the returned type of function
function! s:GetTypeInfoOfReturnedType(contextStack, szFunctionName)
    let result = {}

    let szFilter = "index(['f', 'p'], v:val.kind[0])>=0"
    let tagItem = s:ResolveSymbol(a:contextStack, a:szFunctionName, szFilter)

    if tagItem != {}
        let szCmdWithoutVariable = substitute(omni#cpp#utils#ExtractCmdFromTagItem(tagItem), '\C\<'.a:szFunctionName.'\>.*', '', 'g')
        let tokens = omni#cpp#tokenizer#Tokenize(omni#cpp#utils#GetCodeFromLine(szCmdWithoutVariable))
        let result = omni#cpp#utils#CreateTypeInfo(omni#cpp#utils#ExtractTypeInfoFromTokens(tokens))
        " TODO: Namespace resolution for result
        return result
    endif
    return result
endfunc

" Resolve a symbol, return a tagItem
" Gets the first symbol found in the context stack
function! s:ResolveSymbol(contextStack, szSymbol, szTagFilter)
    let tagItem = {}
    for szCurrentContext in a:contextStack
        if szCurrentContext != '::'
            let szTagQuery = substitute(szCurrentContext, '^::', '', 'g').'::'.a:szSymbol
        else
            let szTagQuery = a:szSymbol
        endif

        let tagList = omni#common#utils#TagListNoThrow('^'.szTagQuery.'$')
        call filter(tagList, a:szTagFilter)
        if len(tagList)
            let tagItem = tagList[0]
            break
        endif
    endfor
    return tagItem
endfunc

" Return if the tag item represent an unnamed type
function! s:IsUnnamedType(tagItem)
    let bResult = 0
    if has_key(a:tagItem, 'typeref')
        " Note: Thanks for __anon !
        let bResult = match(a:tagItem.typeref, '\C\<__anon') >= 0
    endif
    return bResult
endfunc

" Search the declaration of a variable and return the type info
function! s:SearchTypeInfoOfDecl(szVariable)
    let szReVariable = '\C\<'.a:szVariable.'\>'

    let originalPos = getpos('.')
    let origPos = originalPos[1:2]
    let curPos = origPos
    let stopPos = origPos
    
    while curPos !=[0,0]
        " We go to the start of the current scope
        let curPos = searchpairpos('{', '', '}', 'bW', g:omni#cpp#utils#expIgnoreComments)
        if curPos != [0,0]
            let matchPos = curPos
            " Now want to search our variable but we don't want to go in child
            " scope
            while matchPos != [0,0]
                let matchPos = searchpos('{\|'.szReVariable, 'W', stopPos[0])
                if matchPos != [0,0]
                    " We ignore matches under comment
                    if omni#cpp#utils#IsCursorInCommentOrString()
                        continue
                    endif

                    " Getting the current line
                    let szLine = getline('.')
                    if match(szLine, szReVariable)>=0
                        " We found our variable
                        " Check if the current instruction is a decl instruction
                        let tokens = omni#cpp#utils#TokenizeCurrentInstruction()
                        let szTypeInfo = s:ExtractTypeInfoFromDecl(tokens)
                        if szTypeInfo != ''
                            call setpos('.', originalPos)
                            return omni#cpp#utils#CreateTypeInfo(szTypeInfo)
                        endif
                    else
                        " We found a child scope, we don't want to go in, thus
                        " we search for the end } of this child scope
                        let bracketEnd = searchpairpos('{', '', '}', 'nW', g:omni#cpp#utils#expIgnoreComments)
                        if bracketEnd == [0,0]
                            break
                        endif

                        if bracketEnd[0] >= stopPos[0]
                            " The end of the scope is after our cursor we stop
                            " the search
                            break
                        else
                            " We move the cursor and continue to search our
                            " variable
                            call setpos('.', [0, bracketEnd[0], bracketEnd[1], 0])
                        endif
                    endif
                endif
            endwhile

            " Backing to the start of the scope
            call setpos('.', [0,curPos[0], curPos[1], 0])
            let stopPos = curPos
        endif
    endwhile

    let result = {}
    if searchdecl(a:szVariable, 0, 1)==0 && !omni#cpp#utils#IsCursorInCommentOrString()
        let tokens = omni#cpp#utils#TokenizeCurrentInstruction()
        let szTypeInfo = s:ExtractTypeInfoFromDecl(tokens)
        if szTypeInfo != ''
            let result = omni#cpp#utils#CreateTypeInfo(szTypeInfo)
        endif
    endif

    call setpos('.', originalPos)

    return result
endfunc

" Search a declaration
" @return
"   - tokens of the current instruction if success
"   - empty list if failure
function! s:SearchDecl(szVariable)
    let result = {}
    let originalPos = getpos('.')
    let searchResult = searchdecl(a:szVariable, 0, 1)
    if searchResult==0
        " searchdecl() may detect a decl if the variable is in a conditional
        " instruction (if, elseif, while etc...)
        " We have to check if the detected decl is really a decl instruction
        let tokens = omni#cpp#utils#TokenizeCurrentInstruction()
        for token in tokens
            " Simple test
            if index(['if', 'elseif', 'while', 'for', 'switch'], token.value)>=0
                " Invalid declaration instruction
                call setpos('.', originalPos)
                return result
            endif
        endfor

        let szTypeInfo = s:ExtractTypeInfoFromDecl(tokens)
        if szTypeInfo != ''
            let result = omni#cpp#utils#CreateTypeInfo(szTypeInfo)
        endif
    endif
    call setpos('.', originalPos)
    return result
endfunc

" Extract the type info string from an instruction.
" We use a small parser to extract the type
" We parse the code according to a C++ BNF from: http://www.nongnu.org/hcb/#basic.link
" @param tokens: token list of the current instruction
function! s:ExtractTypeInfoFromDecl(tokens)
    return omni#cpp#utils#ExtractTypeInfoFromTokens(a:tokens)
endfunc

" Convert tokens to string
function! s:TokensToString(tokens)
    let result = ''
    for token in a:tokens
        let result = result . token.value . ' '
    endfor
    return result[:-2]
endfunc

" Resolve a cast.
" Resolve a C++ cast
" @param list of token. tokens must be a list that represents
" a cast expression (C++ cast) the function does not control
" if it's a cast or not
" eg: static_cast<MyClass*>(something)
" @return type info string
function! s:ResolveCppCast(tokens)
    return omni#cpp#utils#ExtractTypeInfoFromTokens(s:ResolveCast(a:tokens, '<', '>'))
endfunc

" Resolve a cast.
" Resolve a C cast
" @param list of token. tokens must be a list that represents
" a cast expression (C cast) the function does not control
" if it's a cast or not
" eg: (MyClass*)something
" @return type info string
function! s:ResolveCCast(tokens)
    return omni#cpp#utils#ExtractTypeInfoFromTokens(s:ResolveCast(a:tokens, '(', ')'))
endfunc

" Resolve a cast.
" Resolve a C cast
" @param list of token. tokens must be a list that represents
" a cast expression (C cast) the function does not control
" if it's a cast or not
" eg: (MyClass*)something
" @return type tokens
function! s:ResolveCast(tokens, startChar, endChar)
    let tokens = omni#cpp#utils#BuildParenthesisGroups(a:tokens)

    " We remove useless parenthesis eg: (((MyClass)))
    let tokens = omni#cpp#utils#SimplifyParenthesis(tokens)

    let countItem=0
    let startIndex = -1
    let endIndex = -1 
    let i = 0
    for token in tokens
        if startIndex==-1
            if token.value==a:startChar
                let countItem += 1
                let startIndex = i
            endif
        else
            if token.value==a:startChar
                let countItem += 1
            elseif token.value==a:endChar
                let countItem -= 1
            endif

            if countItem==0
                let endIndex = i
                break
            endif
        endif
        let i+=1
    endfor

    return tokens[startIndex+1 : endIndex-1]
endfunc