예제 #1
0
파일: IndexerJob.cpp 프로젝트: jbulow/rtags
void IndexerJob::handleInclude(const CXCursor &cursor, CXCursorKind kind, const Location &location)
{
    assert(kind == CXCursor_InclusionDirective);
    (void)kind;
    CXFile includedFile = clang_getIncludedFile(cursor);
    if (includedFile) {
        const Location refLoc(includedFile, 0);
        if (!refLoc.isNull()) {
            {
                String include = "#include ";
                const Path path = refLoc.path();
                mData->symbolNames[(include + path)].insert(location);
                mData->symbolNames[(include + path.fileName())].insert(location);
            }
            CursorInfo &info = mData->symbols[location];
            info.targets.insert(refLoc);
            info.kind = cursor.kind;
            info.definition = false;
            info.symbolName = "#include " + RTags::eatString(clang_getCursorDisplayName(cursor));
            info.symbolLength = info.symbolName.size() + 2;
            // this fails for things like:
            // # include    <foobar.h>
        }
    }
}
예제 #2
0
void ClangIndexer::handleInclude(const CXCursor &cursor, CXCursorKind kind, const Location &location)
{
    assert(kind == CXCursor_InclusionDirective);
    (void)kind;
    CXFile includedFile = clang_getIncludedFile(cursor);
    if (includedFile) {
        const Location refLoc = createLocation(includedFile, 1, 1);
        if (!refLoc.isNull()) {
            {
                String include = "#include ";
                const Path path = refLoc.path();
                assert(mSource.fileId);
                mData->dependencies[refLoc.fileId()].insert(mSource.fileId);
                mData->symbolNames[(include + path)].insert(location);
                mData->symbolNames[(include + path.fileName())].insert(location);
            }
            std::shared_ptr<CursorInfo> &info = mData->symbols[location];
            if (!info)
                info = std::make_shared<CursorInfo>();
            info->targets.insert(refLoc);
            info->kind = cursor.kind;
            info->definition = false;
            info->symbolName = "#include " + RTags::eatString(clang_getCursorDisplayName(cursor));
            info->symbolLength = info->symbolName.size() + 2;
            // this fails for things like:
            // # include    <foobar.h>
        }
    }
}
예제 #3
0
std::string libclang_vim::stringize_included_file(CXCursor const& cursor) {
    CXFile included_file = clang_getIncludedFile(cursor);
    if (included_file == nullptr) {
        return "";
    }

    cxstring_ptr included_file_name = clang_getFileName(included_file);
    return std::string("'included_file':'") + to_c_str(included_file_name) +
           "',";
}
예제 #4
0
SourceRangeContainer FollowSymbol::followSymbol(CXTranslationUnit tu,
                                                const Cursor &fullCursor,
                                                uint line,
                                                uint column)
{
    std::unique_ptr<Tokens> tokens(new Tokens(fullCursor));

    if (!tokens->tokenCount)
        tokens.reset(new Tokens(tu));

    if (!tokens->tokenCount)
        return SourceRangeContainer();

    QVector<CXCursor> cursors(static_cast<int>(tokens->tokenCount));
    clang_annotateTokens(tu, tokens->data, tokens->tokenCount, cursors.data());
    int tokenIndex = getTokenIndex(tu, *tokens, line, column);
    QTC_ASSERT(tokenIndex >= 0, return SourceRangeContainer());

    const Utf8String tokenSpelling = ClangString(
                clang_getTokenSpelling(tu, tokens->data[tokenIndex]));
    if (tokenSpelling.isEmpty())
        return SourceRangeContainer();

    Cursor cursor{cursors[tokenIndex]};

    if (cursor.kind() == CXCursor_InclusionDirective) {
        CXFile file = clang_getIncludedFile(cursors[tokenIndex]);
        const ClangString filename(clang_getFileName(file));
        const SourceLocation loc(tu, filename, 1, 1);
        return SourceRange(loc, loc);
    }

    // For definitions we can always find a declaration in current TU
    if (cursor.isDefinition())
        return extractMatchingTokenRange(cursor.canonical(), tokenSpelling);

    if (!cursor.isDeclaration()) {
        // This is the symbol usage
        // We want to return definition
        cursor = cursor.referenced();
        if (cursor.isNull() || !cursor.isDefinition()) {
            // We can't find definition in this TU
            return SourceRangeContainer();
        }
        return extractMatchingTokenRange(cursor, tokenSpelling);
    }

    cursor = cursor.definition();
    // If we are able to find a definition in current TU
    if (!cursor.isNull())
        return extractMatchingTokenRange(cursor, tokenSpelling);

    return SourceRangeContainer();
}
예제 #5
0
SEXP R_clang_getIncludedFile(SEXP r_cursor)
{
    SEXP r_ans = R_NilValue;
    CXCursor cursor = * GET_REF(r_cursor, CXCursor);
    
    CXFile ans;
    ans = clang_getIncludedFile(cursor);
    
    r_ans = R_createRef(ans, "CXFile") ;
    
    return(r_ans);
} 
예제 #6
0
파일: DumpThread.cpp 프로젝트: vporpo/rtags
void DumpThread::handleInclude(const Location &loc, const CXCursor &cursor)
{
    CXFile includedFile = clang_getIncludedFile(cursor);
    if (includedFile) {
        CXStringScope fn = clang_getFileName(includedFile);
        const char *cstr = clang_getCString(fn);
        if (!cstr) {
            clang_disposeString(fn);
            return;
        }
        const Path p = Path::resolved(cstr);
        clang_disposeString(fn);
        const uint32_t fileId = Location::insertFile(p);
        Dep *&source = mDependencies[loc.fileId()];
        if (!source)
            source = new Dep(loc.fileId());
        Dep *&include = mDependencies[fileId];
        if (!include)
            include = new Dep(fileId);
        source->include(include);
    }
}
예제 #7
0
파일: clang++.cpp 프로젝트: mythagel/cxxide
file cursor::includedFile()
{
    return { clang_getIncludedFile(cur) };
}
예제 #8
0
// Desired functions:
//      Go to definition of variable/function
//      Go to declaration of function/class
bool Tokenizer::findToken(eFindTokenTypes ft, size_t origOffset, std::string &fn,
        size_t &line)
    {
    CLangAutoLock lock(mCLangLock, __LINE__, this);
    CXCursor startCursor = getCursorAtOffset(mTransUnit, mSourceFile, origOffset);
    DUMP_PARSE("find:start cursor", startCursor);
    // Instantiating type - <class> <type> - CXCursor_TypeRef
    // Method declaration - <class> { <method>(); }; CXCursor_NoDeclFound
    // Method definition - <class>::<method>(){} - CXCursor_CXXMethod
    // Class/method usage - <class>.<method>()
    // Instance usage - method(){ int v = typename[4]; } - CXCursor_DeclStmt
    //          clang_getCursorSemanticParent returns method
    //          clang_getCursorDefinition returns invalid
    if(startCursor.kind == CXCursor_InclusionDirective)
        {
        CXFile file = clang_getIncludedFile(startCursor);
        if(file)
            {
            fn = getDisposedString(clang_getFileName(file));
            line = 1;
            }
        else
            {
            /// @todo - need to get the full path.
    //      CXStringDisposer cfn = clang_getCursorSpelling(cursor);
    //      fn = cfn;
            line = 1;
            }
        }
    else
        {
        CXCursor cursor = startCursor;
        switch(ft)
            {
            case FT_FindDecl:
                cursor = clang_getCursorReferenced(startCursor);
                DUMP_PARSE("find:decl", cursor);
                break;

            case FT_FindDef:
                // If instantiating a type (CXCursor_TypeRef), this goes to the type declaration.
                cursor = clang_getCursorDefinition(startCursor);
                // Method call can return invalid file when the definition is not in this
                // translation unit.
                if(clang_getCursorKind(cursor) == CXCursor_InvalidFile)
                    {
                    DUMP_PARSE("find:def-invalid", cursor);
                    cursor = clang_getCursorReferenced(startCursor);
                    }
                DUMP_PARSE("find:def", cursor);
            //      cursor = clang_getCursor(mTransUnit, clang_getCursorLocation(cursor));
            //      cursor = clang_getCursorDefinition(cursor);
                break;

            //          cursor = clang_getCursorReferenced(cursor);
            //  cursor = clang_getCanonicalCursor(cursor);
            //  cursor = clang_getCursorSemanticParent(cursor);
            //  cursor = clang_getCursorLexicalParent(cursor);
            }
        if(!clang_Cursor_isNull(cursor))
            {
            CXSourceLocation loc = clang_getCursorLocation(cursor);

            CXFile file;
            unsigned int uline;
            clang_getFileLocation(loc, &file, &uline, nullptr, nullptr);
            if(file)
                {
                line = uline;
                fn = getDisposedString(clang_getFileName(file));
                }
            }
        }
    return(fn.size() > 0);
    }