Zengtudor/ccls
1
0
Fork 0
mirror of https://github.com/MaskRay/ccls.git synced 2025-04-14 21:02:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Jacob Dufault 2017-02-22 00:52:00 -08:00
parent 358b4434c2
commit ce4c2232d7
20 changed files with 619 additions and 1873 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
compilation_database_loader.cc Normal file
View File

@ -0,0 +1,41 @@
#include "compilation_database_loader.h"
#include <iostream>
#include <clang-c/CXCompilationDatabase.h>
#include "libclangmm/Utility.h"
std::vector<CompilationEntry> LoadCompilationEntriesFromDirectory(const std::string& project_directory) {
CXCompilationDatabase_Error cx_db_load_error;
CXCompilationDatabase cx_db = clang_CompilationDatabase_fromDirectory(project_directory.c_str(), &cx_db_load_error);
if (cx_db_load_error == CXCompilationDatabase_CanNotLoadDatabase) {
std::cerr << "[FATAL]: Unable to load compile_commands.json located at \"" << project_directory << "\"";
exit(1);
}
CXCompileCommands cx_commands = clang_CompilationDatabase_getAllCompileCommands(cx_db);
unsigned int num_commands = clang_CompileCommands_getSize(cx_commands);
std::vector<CompilationEntry> result;
for (unsigned int i = 0; i < num_commands; i++) {
CXCompileCommand cx_command = clang_CompileCommands_getCommand(cx_commands, i);
CompilationEntry entry;
entry.directory = clang::ToString(clang_CompileCommand_getDirectory(cx_command));
entry.filename = clang::ToString(clang_CompileCommand_getFilename(cx_command));
unsigned int num_args = clang_CompileCommand_getNumArgs(cx_command);
entry.args.reserve(num_args);
for (unsigned int j = 0; j < num_args; ++j) {
entry.args.push_back(clang::ToString(clang_CompileCommand_getArg(cx_command, j)));
}
result.push_back(entry);
}
clang_CompileCommands_dispose(cx_commands);
clang_CompilationDatabase_dispose(cx_db);
return result;
}

12
compilation_database_loader.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <string>
#include <vector>
struct CompilationEntry {
std::string directory;
std::string filename;
std::vector<std::string> args;
};
std::vector<CompilationEntry> LoadCompilationEntriesFromDirectory(const std::string& project_directory);

1421
cxxopts.hpp
View File

File diff suppressed because it is too large Load Diff

9
full_tests/simple_cross_reference/a.cc Normal file
View File

@ -0,0 +1,9 @@
#include "a.h"
namespace {
void LocalA() {
Common();
}
} // namespace
void Common() {}

6
full_tests/simple_cross_reference/a.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef A_H_
#define A_H_
void Common();
#endif // A_H_

7
full_tests/simple_cross_reference/b.cc Normal file
View File

@ -0,0 +1,7 @@
#include "a.h"
#if RANDOM_DEFINE
static void LocaB() {
Common();
}
#endif // RANDOM_DEFINE

12
full_tests/simple_cross_reference/compile_commands.json Normal file
View File

@ -0,0 +1,12 @@
[
{
"directory" : "full_tests/simple_cross_reference",
"command" : "clang -c -o a.o a.cc",
"file" : "full_tests/simple_cross_reference/a.cc"
},
{
"directory" : "full_tests/simple_cross_reference",
"command" : "clang -DRANDOM_DEFINE -c -o b.o b.cc",
"file" : "full_tests/simple_cross_reference/b.cc"
}
]

330
main.cpp → indexer.cpp
View File

@ -1,324 +1,4 @@
#include <algorithm> #include "indexer.h"
#include <iostream>
#include <cstdint>
#include <cassert>
#include <fstream>
#include <unordered_map>
#include "libclangmm/clangmm.h"
#include "libclangmm/Utility.h"
#include "bitfield.h"
#include "utils.h"
#include "optional.h"
#include <rapidjson/writer.h>
#include <rapidjson/prettywriter.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/document.h>
struct TypeDef;
struct FuncDef;
struct VarDef;
using FileId = int64_t;
using namespace std::experimental;
// TODO: Move off of this weird wrapper, use struct with custom wrappers
// directly.
BEGIN_BITFIELD_TYPE(Location, uint64_t)
ADD_BITFIELD_MEMBER(interesting, /*start:*/ 0, /*len:*/ 1); // 2 values
ADD_BITFIELD_MEMBER(file_id, /*start:*/ 1, /*len:*/ 29); // 536,870,912 values
ADD_BITFIELD_MEMBER(line, /*start:*/ 30, /*len:*/ 20); // 1,048,576 values
ADD_BITFIELD_MEMBER(column, /*start:*/ 50, /*len:*/ 14); // 16,384 values
Location(bool interesting, FileId file_id, uint32_t line, uint32_t column) {
this->interesting = interesting;
this->file_id = file_id;
this->line = line;
this->column = column;
}
std::string ToString() {
// Output looks like this:
//
// *1:2:3
//
// * => interesting
// 1 => file id
// 2 => line
// 3 => column
std::string result;
if (interesting)
result += '*';
result += std::to_string(file_id);
result += ':';
result += std::to_string(line);
result += ':';
result += std::to_string(column);
return result;
}
// Compare two Locations and check if they are equal. Ignores the value of
// |interesting|.
// operator== doesn't seem to work properly...
bool IsEqualTo(const Location& o) {
// When comparing, ignore the value of |interesting|.
return (wrapper.value >> 1) == (o.wrapper.value >> 1);
}
Location WithInteresting(bool interesting) {
Location result = *this;
result.interesting = interesting;
return result;
}
END_BITFIELD_TYPE()
struct FileDb {
std::unordered_map<std::string, FileId> file_path_to_file_id;
std::unordered_map<FileId, std::string> file_id_to_file_path;
FileDb() {
// Reserve id 0 for unfound.
file_path_to_file_id[""] = 0;
file_id_to_file_path[0] = "";
}
Location Resolve(const CXSourceLocation& cx_loc, bool interesting) {
CXFile file;
unsigned int line, column, offset;
clang_getSpellingLocation(cx_loc, &file, &line, &column, &offset);
FileId file_id;
if (file != nullptr) {
std::string path = clang::ToString(clang_getFileName(file));
auto it = file_path_to_file_id.find(path);
if (it != file_path_to_file_id.end()) {
file_id = it->second;
}
else {
file_id = file_path_to_file_id.size();
file_path_to_file_id[path] = file_id;
file_id_to_file_path[file_id] = path;
}
}
return Location(interesting, file_id, line, column);
}
Location Resolve(const CXIdxLoc& cx_idx_loc, bool interesting) {
CXSourceLocation cx_loc = clang_indexLoc_getCXSourceLocation(cx_idx_loc);
return Resolve(cx_loc, interesting);
}
Location Resolve(const CXCursor& cx_cursor, bool interesting) {
return Resolve(clang_getCursorLocation(cx_cursor), interesting);
}
Location Resolve(const clang::Cursor& cursor, bool interesting) {
return Resolve(cursor.cx_cursor, interesting);
}
};
template<typename T>
struct LocalId {
uint64_t local_id;
LocalId() : local_id(0) {} // Needed for containers. Do not use directly.
explicit LocalId(uint64_t local_id) : local_id(local_id) {}
bool operator==(const LocalId<T>& other) {
return local_id == other.local_id;
}
};
template<typename T>
bool operator==(const LocalId<T>& a, const LocalId<T>& b) {
return a.local_id == b.local_id;
}
using TypeId = LocalId<TypeDef>;
using FuncId = LocalId<FuncDef>;
using VarId = LocalId<VarDef>;
template<typename T>
struct Ref {
LocalId<T> id;
Location loc;
Ref(LocalId<T> id, Location loc) : id(id), loc(loc) {}
};
using TypeRef = Ref<TypeDef>;
using FuncRef = Ref<FuncDef>;
using VarRef = Ref<VarDef>;
// TODO: skip as much forward-processing as possible when |is_system_def| is
// set to false.
// TODO: Either eliminate the defs created as a by-product of cross-referencing,
// or do not emit things we don't have definitions for.
struct TypeDef {
bool is_system_def = false;
// General metadata.
TypeId id;
std::string usr;
std::string short_name;
std::string qualified_name;
// While a class/type can technically have a separate declaration/definition,
// it doesn't really happen in practice. The declaration never contains
// comments or insightful information. The user always wants to jump from
// the declaration to the definition - never the other way around like in
// functions and (less often) variables.
//
// It's also difficult to identify a `class Foo;` statement with the clang
// indexer API (it's doable using cursor AST traversal), so we don't bother
// supporting the feature.
optional<Location> definition;
// If set, then this is the same underlying type as the given value (ie, this
// type comes from a using or typedef statement).
optional<TypeId> alias_of;
// Immediate parent and immediate derived types.
std::vector<TypeId> parents;
std::vector<TypeId> derived;
// Types, functions, and variables defined in this type.
std::vector<TypeId> types;
std::vector<FuncId> funcs;
std::vector<VarId> vars;
// Every usage, useful for things like renames.
// NOTE: Do not insert directly! Use AddUsage instead.
std::vector<Location> uses;
TypeDef(TypeId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
//std::cout << "Creating type with usr " << usr << std::endl;
}
void AddUsage(Location loc, bool insert_if_not_present = true) {
if (is_system_def)
return;
for (int i = uses.size() - 1; i >= 0; --i) {
if (uses[i].IsEqualTo(loc)) {
if (loc.interesting)
uses[i].interesting = true;
return;
}
}
if (insert_if_not_present)
uses.push_back(loc);
}
};
struct FuncDef {
bool is_system_def = false;
// General metadata.
FuncId id;
std::string usr;
std::string short_name;
std::string qualified_name;
optional<Location> declaration;
optional<Location> definition;
// Type which declares this one (ie, it is a method)
optional<TypeId> declaring_type;
// Method this method overrides.
optional<FuncId> base;
// Methods which directly override this one.
std::vector<FuncId> derived;
// Local variables defined in this function.
std::vector<VarId> locals;
// Functions which call this one.
// TODO: Functions can get called outside of just functions - for example,
// they can get called in static context (maybe redirect to main?)
// or in class initializer list (redirect to class ctor?)
// - Right now those usages will not get listed here (but they should be
// inside of all_uses).
std::vector<FuncRef> callers;
// Functions that this function calls.
std::vector<FuncRef> callees;
// All usages. For interesting usages, see callees.
std::vector<Location> uses;
FuncDef(FuncId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
}
};
struct VarDef {
bool is_system_def = false;
// General metadata.
VarId id;
std::string usr;
std::string short_name;
std::string qualified_name;
optional<Location> declaration;
// TODO: definitions should be a list of locations, since there can be more
// than one.
optional<Location> definition;
// Type of the variable.
optional<TypeId> variable_type;
// Type which declares this one (ie, it is a method)
optional<TypeId> declaring_type;
// Usages.
std::vector<Location> uses;
VarDef(VarId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
}
};
struct ParsingDatabase {
// NOTE: Every Id is resolved to a file_id of 0. The correct file_id needs
// to get fixed up when inserting into the real db.
std::unordered_map<std::string, TypeId> usr_to_type_id;
std::unordered_map<std::string, FuncId> usr_to_func_id;
std::unordered_map<std::string, VarId> usr_to_var_id;
std::vector<TypeDef> types;
std::vector<FuncDef> funcs;
std::vector<VarDef> vars;
FileDb file_db;
ParsingDatabase();
TypeId ToTypeId(const std::string& usr);
FuncId ToFuncId(const std::string& usr);
VarId ToVarId(const std::string& usr);
TypeId ToTypeId(const CXCursor& usr);
FuncId ToFuncId(const CXCursor& usr);
VarId ToVarId(const CXCursor& usr);
TypeDef* Resolve(TypeId id);
FuncDef* Resolve(FuncId id);
VarDef* Resolve(VarId id);
std::string ToString();
};
ParsingDatabase::ParsingDatabase() {} ParsingDatabase::ParsingDatabase() {}
@ -1284,9 +964,7 @@ void indexEntityReference(CXClientData client_data, const CXIdxEntityRefInfo* re
static bool DUMP_AST = true; static bool DUMP_AST = true;
ParsingDatabase Parse(std::string filename) { ParsingDatabase Parse(std::string filename, std::vector<std::string> args) {
std::vector<std::string> args;
clang::Index index(0 /*excludeDeclarationsFromPCH*/, 0 /*displayDiagnostics*/); clang::Index index(0 /*excludeDeclarationsFromPCH*/, 0 /*displayDiagnostics*/);
clang::TranslationUnit tu(index, filename, args); clang::TranslationUnit tu(index, filename, args);
@ -1412,6 +1090,8 @@ void WriteToFile(const std::string& filename, const std::string& content) {
} }
int mai2n(int argc, char** argv) { int mai2n(int argc, char** argv) {
// TODO: Assert that we need to be on clang >= 3.9.1
/* /*
ParsingDatabase db = Parse("tests/vars/function_local.cc"); ParsingDatabase db = Parse("tests/vars/function_local.cc");
std::cout << std::endl << "== Database ==" << std::endl; std::cout << std::endl << "== Database ==" << std::endl;
@ -1448,7 +1128,7 @@ int mai2n(int argc, char** argv) {
// Run test. // Run test.
std::cout << "[START] " << path << std::endl; std::cout << "[START] " << path << std::endl;
ParsingDatabase db = Parse(path); ParsingDatabase db = Parse(path, {});
std::string actual_output = db.ToString(); std::string actual_output = db.ToString();
//WriteToFile("output.json", actual_output); //WriteToFile("output.json", actual_output);

325
indexer.h Normal file
View File

@ -0,0 +1,325 @@
#pragma once
#include <algorithm>
#include <iostream>
#include <cstdint>
#include <cassert>
#include <fstream>
#include <unordered_map>
#include "libclangmm/clangmm.h"
#include "libclangmm/Utility.h"
#include "bitfield.h"
#include "utils.h"
#include "optional.h"
#include <rapidjson/writer.h>
#include <rapidjson/prettywriter.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/document.h>
struct TypeDef;
struct FuncDef;
struct VarDef;
using FileId = int64_t;
using namespace std::experimental;
// TODO: Move off of this weird wrapper, use struct with custom wrappers
// directly.
BEGIN_BITFIELD_TYPE(Location, uint64_t)
ADD_BITFIELD_MEMBER(interesting, /*start:*/ 0, /*len:*/ 1); // 2 values
ADD_BITFIELD_MEMBER(file_id, /*start:*/ 1, /*len:*/ 29); // 536,870,912 values
ADD_BITFIELD_MEMBER(line, /*start:*/ 30, /*len:*/ 20); // 1,048,576 values
ADD_BITFIELD_MEMBER(column, /*start:*/ 50, /*len:*/ 14); // 16,384 values
Location(bool interesting, FileId file_id, uint32_t line, uint32_t column) {
this->interesting = interesting;
this->file_id = file_id;
this->line = line;
this->column = column;
}
std::string ToString() {
// Output looks like this:
//
// *1:2:3
//
// * => interesting
// 1 => file id
// 2 => line
// 3 => column
std::string result;
if (interesting)
result += '*';
result += std::to_string(file_id);
result += ':';
result += std::to_string(line);
result += ':';
result += std::to_string(column);
return result;
}
// Compare two Locations and check if they are equal. Ignores the value of
// |interesting|.
// operator== doesn't seem to work properly...
bool IsEqualTo(const Location& o) {
// When comparing, ignore the value of |interesting|.
return (wrapper.value >> 1) == (o.wrapper.value >> 1);
}
Location WithInteresting(bool interesting) {
Location result = *this;
result.interesting = interesting;
return result;
}
END_BITFIELD_TYPE()
struct FileDb {
std::unordered_map<std::string, FileId> file_path_to_file_id;
std::unordered_map<FileId, std::string> file_id_to_file_path;
FileDb() {
// Reserve id 0 for unfound.
file_path_to_file_id[""] = 0;
file_id_to_file_path[0] = "";
}
Location Resolve(const CXSourceLocation& cx_loc, bool interesting) {
CXFile file;
unsigned int line, column, offset;
clang_getSpellingLocation(cx_loc, &file, &line, &column, &offset);
FileId file_id;
if (file != nullptr) {
std::string path = clang::ToString(clang_getFileName(file));
auto it = file_path_to_file_id.find(path);
if (it != file_path_to_file_id.end()) {
file_id = it->second;
}
else {
file_id = file_path_to_file_id.size();
file_path_to_file_id[path] = file_id;
file_id_to_file_path[file_id] = path;
}
}
return Location(interesting, file_id, line, column);
}
Location Resolve(const CXIdxLoc& cx_idx_loc, bool interesting) {
CXSourceLocation cx_loc = clang_indexLoc_getCXSourceLocation(cx_idx_loc);
return Resolve(cx_loc, interesting);
}
Location Resolve(const CXCursor& cx_cursor, bool interesting) {
return Resolve(clang_getCursorLocation(cx_cursor), interesting);
}
Location Resolve(const clang::Cursor& cursor, bool interesting) {
return Resolve(cursor.cx_cursor, interesting);
}
};
template<typename T>
struct LocalId {
uint64_t local_id;
LocalId() : local_id(0) {} // Needed for containers. Do not use directly.
explicit LocalId(uint64_t local_id) : local_id(local_id) {}
bool operator==(const LocalId<T>& other) {
return local_id == other.local_id;
}
};
template<typename T>
bool operator==(const LocalId<T>& a, const LocalId<T>& b) {
return a.local_id == b.local_id;
}
using TypeId = LocalId<TypeDef>;
using FuncId = LocalId<FuncDef>;
using VarId = LocalId<VarDef>;
template<typename T>
struct Ref {
LocalId<T> id;
Location loc;
Ref(LocalId<T> id, Location loc) : id(id), loc(loc) {}
};
using TypeRef = Ref<TypeDef>;
using FuncRef = Ref<FuncDef>;
using VarRef = Ref<VarDef>;
// TODO: skip as much forward-processing as possible when |is_system_def| is
// set to false.
// TODO: Either eliminate the defs created as a by-product of cross-referencing,
// or do not emit things we don't have definitions for.
struct TypeDef {
bool is_system_def = false;
// General metadata.
TypeId id;
std::string usr;
std::string short_name;
std::string qualified_name;
// While a class/type can technically have a separate declaration/definition,
// it doesn't really happen in practice. The declaration never contains
// comments or insightful information. The user always wants to jump from
// the declaration to the definition - never the other way around like in
// functions and (less often) variables.
//
// It's also difficult to identify a `class Foo;` statement with the clang
// indexer API (it's doable using cursor AST traversal), so we don't bother
// supporting the feature.
optional<Location> definition;
// If set, then this is the same underlying type as the given value (ie, this
// type comes from a using or typedef statement).
optional<TypeId> alias_of;
// Immediate parent and immediate derived types.
std::vector<TypeId> parents;
std::vector<TypeId> derived;
// Types, functions, and variables defined in this type.
std::vector<TypeId> types;
std::vector<FuncId> funcs;
std::vector<VarId> vars;
// Every usage, useful for things like renames.
// NOTE: Do not insert directly! Use AddUsage instead.
std::vector<Location> uses;
TypeDef(TypeId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
//std::cout << "Creating type with usr " << usr << std::endl;
}
void AddUsage(Location loc, bool insert_if_not_present = true) {
if (is_system_def)
return;
for (int i = uses.size() - 1; i >= 0; --i) {
if (uses[i].IsEqualTo(loc)) {
if (loc.interesting)
uses[i].interesting = true;
return;
}
}
if (insert_if_not_present)
uses.push_back(loc);
}
};
struct FuncDef {
bool is_system_def = false;
// General metadata.
FuncId id;
std::string usr;
std::string short_name;
std::string qualified_name;
optional<Location> declaration;
optional<Location> definition;
// Type which declares this one (ie, it is a method)
optional<TypeId> declaring_type;
// Method this method overrides.
optional<FuncId> base;
// Methods which directly override this one.
std::vector<FuncId> derived;
// Local variables defined in this function.
std::vector<VarId> locals;
// Functions which call this one.
// TODO: Functions can get called outside of just functions - for example,
// they can get called in static context (maybe redirect to main?)
// or in class initializer list (redirect to class ctor?)
// - Right now those usages will not get listed here (but they should be
// inside of all_uses).
std::vector<FuncRef> callers;
// Functions that this function calls.
std::vector<FuncRef> callees;
// All usages. For interesting usages, see callees.
std::vector<Location> uses;
FuncDef(FuncId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
}
};
struct VarDef {
bool is_system_def = false;
// General metadata.
VarId id;
std::string usr;
std::string short_name;
std::string qualified_name;
optional<Location> declaration;
// TODO: definitions should be a list of locations, since there can be more
// than one.
optional<Location> definition;
// Type of the variable.
optional<TypeId> variable_type;
// Type which declares this one (ie, it is a method)
optional<TypeId> declaring_type;
// Usages.
std::vector<Location> uses;
VarDef(VarId id, const std::string& usr) : id(id), usr(usr) {
assert(usr.size() > 0);
}
};
struct ParsingDatabase {
// NOTE: Every Id is resolved to a file_id of 0. The correct file_id needs
// to get fixed up when inserting into the real db.
std::unordered_map<std::string, TypeId> usr_to_type_id;
std::unordered_map<std::string, FuncId> usr_to_func_id;
std::unordered_map<std::string, VarId> usr_to_var_id;
std::vector<TypeDef> types;
std::vector<FuncDef> funcs;
std::vector<VarDef> vars;
FileDb file_db;
ParsingDatabase();
TypeId ToTypeId(const std::string& usr);
FuncId ToFuncId(const std::string& usr);
VarId ToVarId(const std::string& usr);
TypeId ToTypeId(const CXCursor& usr);
FuncId ToFuncId(const CXCursor& usr);
VarId ToVarId(const CXCursor& usr);
TypeDef* Resolve(TypeId id);
FuncDef* Resolve(FuncId id);
VarDef* Resolve(VarId id);
std::string ToString();
};
ParsingDatabase Parse(std::string filename, std::vector<std::string> args);

19
indexer.vcxproj.user Normal file
View File

@ -0,0 +1,19 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LocalDebuggerCommandArguments>--project C:\Users\jacob\Desktop\superindex\indexer\full_tests\simple_cross_reference</LocalDebuggerCommandArguments>
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LocalDebuggerCommandArguments>--project C:\Users\jacob\Desktop\superindex\indexer\full_tests\simple_cross_reference</LocalDebuggerCommandArguments>
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LocalDebuggerCommandArguments>--project C:\Users\jacob\Desktop\superindex\indexer\full_tests\simple_cross_reference</LocalDebuggerCommandArguments>
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LocalDebuggerCommandArguments>--project C:\Users\jacob\Desktop\superindex\indexer\full_tests\simple_cross_reference</LocalDebuggerCommandArguments>
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
</PropertyGroup>
</Project>

11
libclangmm/CompilationDatabase.cc
View File

@ -1,11 +1,14 @@
#include "CompilationDatabase.h" #include "CompilationDatabase.h"
#include <exception>
clang::CompilationDatabase::CompilationDatabase(const std::string &project_path) { #include <iostream>
clang::CompilationDatabase::CompilationDatabase(const std::string& project_path) {
CXCompilationDatabase_Error error; CXCompilationDatabase_Error error;
cx_db = clang_CompilationDatabase_fromDirectory(project_path.c_str(), &error); cx_db = clang_CompilationDatabase_fromDirectory(project_path.c_str(), &error);
if(error) { if (error == CXCompilationDatabase_CanNotLoadDatabase) {
//TODO: compile_commands.json is missing, create it? std::cerr << "[FATAL]: Unable to load compile_commands.json located at \""
<< project_path << "\"";
exit(1);
} }
} }

26
libclangmm/CompilationDatabase.h
View File

@ -1,18 +1,20 @@
#ifndef COMPILATIONDATABASE_H_ #pragma once
#define COMPILATIONDATABASE_H_
#include <clang-c/CXCompilationDatabase.h>
#include <clang-c/Index.h>
#include <string> #include <string>
#include <clang-c/CXCompilationDatabase.h>
namespace clang { namespace clang {
class CompilationDatabase {
public:
explicit CompilationDatabase(const std::string &project_path);
~CompilationDatabase();
CXCompilationDatabase cx_db; struct CompilationCommand {
}; std::string path;
std::string args;
};
class CompilationDatabase {
public:
explicit CompilationDatabase(const std::string &project_path);
~CompilationDatabase();
CXCompilationDatabase cx_db;
};
} }
#endif // COMPILATIONDATABASE_H_

35
libclangmm/CompileCommand.cc
View File

@ -2,20 +2,27 @@
#include "CompileCommands.h" #include "CompileCommands.h"
#include "Utility.h" #include "Utility.h"
std::string clang::CompileCommand::get_command() { namespace clang {
std::string res;
unsigned N = clang_CompileCommand_getNumArgs(cx_command); CompileCommand::CompileCommand(const CXCompileCommand& command)
for (unsigned i = 0; i < N; i++) { : cx_command(command) {};
res += ToString(clang_CompileCommand_getArg(cx_command, i));
} std::string CompileCommand::get_command() const {
return res; std::string result;
unsigned int num_args = clang_CompileCommand_getNumArgs(cx_command);
for (unsigned int i = 0; i < num_args; i++)
result += ToString(clang_CompileCommand_getArg(cx_command, i));
return result;
} }
std::vector<std::string> clang::CompileCommand::get_command_as_args() { std::vector<std::string> CompileCommand::get_command_as_args() const {
unsigned N = clang_CompileCommand_getNumArgs(cx_command); unsigned num_args = clang_CompileCommand_getNumArgs(cx_command);
std::vector<std::string> res(N); std::vector<std::string> result(num_args);
for (unsigned i = 0; i < N; i++) { for (unsigned i = 0; i < num_args; i++)
res[i] = ToString(clang_CompileCommand_getArg(cx_command, i)); result[i] = ToString(clang_CompileCommand_getArg(cx_command, i));
}
return res; return result;
} }
} // namespace clang

19
libclangmm/CompileCommand.h
View File

@ -1,17 +1,16 @@
#ifndef COMPILECOMMAND_H_ #pragma once
#define COMPILECOMMAND_H_
#include <clang-c/CXCompilationDatabase.h> #include <clang-c/CXCompilationDatabase.h>
#include <vector> #include <vector>
#include <string> #include <string>
namespace clang { namespace clang {
class CompileCommand { class CompileCommand {
public: public:
CompileCommand(const CXCompileCommand& cx_command) : cx_command(cx_command) {}; CompileCommand(const CXCompileCommand& cx_command);
std::string get_command(); std::string get_command() const;
std::vector<std::string> get_command_as_args(); std::vector<std::string> get_command_as_args() const;
CXCompileCommand cx_command; CXCompileCommand cx_command;
}; };
} }
#endif // COMPILECOMMAND_H_

11
libclangmm/CompileCommands.cc
View File

@ -1,10 +1,10 @@
#include "CompileCommands.h" #include "CompileCommands.h"
clang::CompileCommands::CompileCommands(const std::string &filename, CompilationDatabase &db) { clang::CompileCommands::CompileCommands(const CompilationDatabase& db) {
cx_commands = cx_commands =
clang_CompilationDatabase_getCompileCommands(db.cx_db, filename.c_str()); clang_CompilationDatabase_getAllCompileCommands(db.cx_db);
if(clang_CompileCommands_getSize(cx_commands)==0) //if (clang_CompileCommands_getSize(cx_commands) == 0)
cx_commands = clang_CompilationDatabase_getAllCompileCommands(db.cx_db); // cx_commands = clang_CompilationDatabase_getAllCompileCommands(db.cx_db);
} }
clang::CompileCommands::~CompileCommands() { clang::CompileCommands::~CompileCommands() {
@ -15,7 +15,8 @@ std::vector<clang::CompileCommand> clang::CompileCommands::get_commands() {
unsigned N = clang_CompileCommands_getSize(cx_commands); unsigned N = clang_CompileCommands_getSize(cx_commands);
std::vector<CompileCommand> res; std::vector<CompileCommand> res;
for (unsigned i = 0; i < N; i++) { for (unsigned i = 0; i < N; i++) {
res.emplace_back(clang_CompileCommands_getCommand(cx_commands, i)); CXCompileCommand command = clang_CompileCommands_getCommand(cx_commands, i);
res.push_back(command);
} }
return res; return res;
} }

26
libclangmm/CompileCommands.h
View File

@ -1,19 +1,19 @@
#ifndef COMPILECOMMANDS_H_ #pragma once
#define COMPILECOMMANDS_H_
#include "CompilationDatabase.h"
#include "CompileCommand.h"
#include <clang-c/CXCompilationDatabase.h>
#include <string> #include <string>
#include <vector> #include <vector>
#include <clang-c/CXCompilationDatabase.h>
#include "CompilationDatabase.h"
#include "CompileCommand.h"
namespace clang { namespace clang {
class CompileCommands { class CompileCommands {
public: public:
CompileCommands(const std::string &filename, CompilationDatabase &db); CompileCommands(const CompilationDatabase& db);
std::vector<CompileCommand> get_commands(); std::vector<CompileCommand> get_commands();
~CompileCommands(); ~CompileCommands();
CXCompileCommands cx_commands; CXCompileCommands cx_commands;
}; };
} }
#endif // COMPILECOMMANDS_H_

2
libclangmm/Cursor.cc
View File

@ -211,6 +211,7 @@ std::string Cursor::get_type_description() const {
return spelling; return spelling;
} }
#if false
std::string Cursor::evaluate() const { std::string Cursor::evaluate() const {
CXEvalResult eval = clang_Cursor_Evaluate(cx_cursor); CXEvalResult eval = clang_Cursor_Evaluate(cx_cursor);
@ -293,6 +294,7 @@ std::string Cursor::evaluate() const {
} }
#endif
std::string Cursor::get_comments() const { std::string Cursor::get_comments() const {
Cursor referenced = get_referenced(); Cursor referenced = get_referenced();

2
libclangmm/Cursor.h
View File

@ -67,7 +67,7 @@ public:
std::vector<Cursor> get_arguments() const; std::vector<Cursor> get_arguments() const;
bool is_valid_kind() const; bool is_valid_kind() const;
std::string evaluate() const; //std::string evaluate() const;
std::string get_type_description() const; std::string get_type_description() const;
std::string get_comments() const; std::string get_comments() const;

21
libclangmm/TranslationUnit.cc
View File

@ -4,6 +4,7 @@
#include "Utility.h" #include "Utility.h"
#include <fstream> #include <fstream>
#include <sstream> #include <sstream>
#include <cassert>
namespace clang { namespace clang {
@ -20,20 +21,24 @@ TranslationUnit::TranslationUnit(Index &index, const std::string &file_path,
files[0].Contents = buffer.c_str(); files[0].Contents = buffer.c_str();
files[0].Length = buffer.size(); files[0].Length = buffer.size();
cx_tu = clang_parseTranslationUnit(index.cx_index, file_path.c_str(), args.data(), CXErrorCode error_code = clang_parseTranslationUnit2(
args.size(), files, 1, flags); index.cx_index, file_path.c_str(), args.data(), args.size(), files, 1, flags, &cx_tu);
assert(!error_code);
} }
TranslationUnit::TranslationUnit(Index &index, const std::string &file_path, TranslationUnit::TranslationUnit(Index &index, const std::string &file_path,
const std::vector<std::string> &command_line_args, const std::vector<std::string> &command_line_args, unsigned flags) {
unsigned flags) {
// TODO: only push defines for the time being. Might need to pass more flags.
std::vector<const char*> args; std::vector<const char*> args;
for (auto &a : command_line_args) { for (const std::string& a : command_line_args) {
args.push_back(a.c_str()); if (a.size() >= 2 && a[0] == '-' && a[1] == 'D')
args.push_back(a.c_str());
} }
cx_tu = clang_parseTranslationUnit(index.cx_index, file_path.c_str(), args.data(), CXErrorCode error_code = clang_parseTranslationUnit2(
args.size(), nullptr, 0, flags); index.cx_index, file_path.c_str(), args.data(), args.size(), nullptr, 0, flags, &cx_tu);
assert(!error_code);
} }
TranslationUnit::~TranslationUnit() { TranslationUnit::~TranslationUnit() {

157
query_db.cc
View File

@ -3,10 +3,11 @@
#include <string> #include <string>
#include <iostream> #include <iostream>
#include "cxxopts.hpp" #include "compilation_database_loader.h"
#include "optional.h"
using FileId = uint64_t; //#include "cxxopts.hpp"
#include "optional.h"
#include "indexer.h"
struct FileDatabase { struct FileDatabase {
std::unordered_map<std::string, FileId> filename_to_file_id; std::unordered_map<std::string, FileId> filename_to_file_id;
@ -30,10 +31,6 @@ struct File {
std::vector<SymbolIdx> defined_symbols; std::vector<SymbolIdx> defined_symbols;
}; };
struct TypeDef {};
struct FuncDef {};
struct VarDef {};
struct QueryableEntry { struct QueryableEntry {
const char* const str; const char* const str;
}; };
@ -169,36 +166,87 @@ std::istream& operator >> (std::istream& is, Command& obj) {
// TODO: allow user to decide some indexer choices, ie, do we define // TODO: allow user to decide some indexer choices, ie, do we define
// TODO: may want to run indexer in separate process to avoid indexer/compiler crashes? // TODO: may want to run indexer in separate process to avoid indexer/compiler crashes?
std::unordered_map<std::string, std::string> ParseOptions(int argc, char** argv) {
std::unordered_map<std::string, std::string> output;
std::string previous_arg;
for (int i = 1; i < argc; ++i) {
std::string arg = argv[i];
if (arg[0] != '-') {
if (previous_arg.size() == 0) {
std::cerr << "Invalid arguments; switches must start with -" << std::endl;
exit(1);
}
output[previous_arg] = arg;
previous_arg = "";
}
else {
output[arg] = "";
previous_arg = arg;
}
}
return output;
}
bool HasOption(const std::unordered_map<std::string, std::string>& options, const std::string& option) {
return options.find(option) != options.end();
}
int main(int argc, char** argv) { int main(int argc, char** argv) {
// cxxopts throws exceptions... replace/rewrite lib? std::unordered_map<std::string, std::string> options = ParseOptions(argc, argv);
try {
cxxopts::Options options("indexer", "C++ indexer powered by libclang");
options.add_options() if (argc == 1 || options.find("--help") != options.end()) {
("h,help", "Print help (this output)") std::cout << R"help(clang-indexer help:
("list-commands", "Print information about the query commands")
("p,project", "Path to compile_commands.json. Needed for the server, and optionally by clients if there are multiple servers running.")
;
// Server options. General:
options.add_options("server") --help Print this help information.
("server", "Flag indicating that the indexer should create an index that can be queried against using separate invocations of this binary (using the --command flag).", cxxopts::value<bool>()) --help-commands
("cache-dir", "Path to cache index. Database cache will be restored if present. If not present, the index will be in-memory only.") Print all available query commands.
("threads", "Number of threads to use for indexing and querying tasks.") --project Path to compile_commands.json. Needed for the server, and
; optionally by clients if there are multiple servers running.
--print-config
Emit all configuration data this executable is using.
// Client options. Server:
options.add_options("client") --server If present, this binary will run in server mode. The binary
("c,command", "Execute a query command against the index. See --command-help. Presence of this flag indicates that the indexer is in client mode.", cxxopts::value<Command>()) will not return until killed or an exit is requested. The
("f,file", "File name to run the index query on", cxxopts::value<std::string>()) server computes and caches an index of the entire program
("l,location", "A symbol location in the active file the query will operate on. Format is line:column, ie, 10:5, for line 10, column 5.", cxxopts::value<std::string>()) which is then queried by short-lived client processes. A
("preferred-symbol-location", "When looking up symbols, try to return the either the 'declaration' or the 'definition'. Defaults to 'definition'.", cxxopts::value<PreferredSymbolLocation>()) client is created by running this binary with a --command
; flag.
--cache-dir Directory to cache the index and other useful information. If
a previous cache is present, the database will try to reuse
it. If this flag is not present, the database will be
in-memory only.
--threads Number of threads to use for indexing and querying tasks.
This value is optional; a good estimate is computed by
default.
options.parse(argc, argv);
Client:
--command Execute a query command against the index. See
--command-help for a listing of valid commands and a
description of what they do. Presence of this flag indicates
that the indexer is in client mode; this flag is mutually
exclusive with --server.
--location Location of the query. Some commands require only a file,
other require a line and column as well. Format is
filename[:line:column]. For example, "foobar.cc" and
"foobar.cc:1:10" are valid inputs.
--preferred-symbol-location
When looking up symbols, try to return either the
'declaration' or the 'definition'. Defaults to 'definition'.
)help";
exit(0);
}
if (options.count("list-commands")) { if (HasOption(options, "--help-commands")) {
std::cout << R"(Available commands: std::cout << R"(Available commands:
callees: callees:
callers: callers:
@ -228,39 +276,28 @@ int main(int argc, char** argv) {
search: search:
Search for a symbol by name. Search for a symbol by name.
)"; )";
exit(0); exit(0);
}
if (HasOption(options, "--project")) {
std::vector<CompilationEntry> entries = LoadCompilationEntriesFromDirectory(options["--project"]);
std::vector<ParsingDatabase> dbs;
for (const CompilationEntry& entry : entries) {
std::cout << "Parsing " << entry.filename << std::endl;
ParsingDatabase db = Parse(entry.filename, entry.args);
dbs.emplace_back(db);
std::cout << db.ToString() << std::endl << std::endl;
} }
if (argc == 1 || options.count("help")) { std::cin.get();
std::cout << options.help({ "", "server", "client" }) << std::endl; exit(0);
exit(0);
}
}
catch (cxxopts::OptionException exc) {
fail(exc.what());
} }
/*
std::string command;
for (int i = 0; i < argc; ++i) {
if (strcmp(argv[i], "--command") == 0) {
if ((i + 1) >= argc)
fail("missing --command type");
command = argv[i + 1]; std::cout << "Invalid arguments. Try --help.";
} exit(1);
}
if (command == "")
fail("missing --command switch");
if (command == "query") {
}
std::cout << "Running command " << command;
*/
return 0; return 0;
} }