mirror of https://gitlab.com/cppit/libclangmm
38 changed files with 407 additions and 494 deletions
@ -1,24 +1,21 @@
|
||||
#ifndef CODECOMPLETERESULTS_H_ |
||||
#define CODECOMPLETERESULTS_H_ |
||||
#include <clang-c/Index.h> |
||||
#include "TranslationUnit.h" |
||||
#include <map> |
||||
#include "CompletionString.h" |
||||
|
||||
namespace clang { |
||||
class CompletionString; |
||||
|
||||
class CodeCompleteResults { |
||||
public: |
||||
CodeCompleteResults(TranslationUnit *tu, |
||||
const std::string &file_name, |
||||
friend class TranslationUnit; |
||||
CodeCompleteResults(CXTranslationUnit &cx_tu, const std::string &file_name, |
||||
const std::map<std::string, std::string> &buffers, |
||||
int line_num, |
||||
int column); |
||||
unsigned line_num, unsigned column); |
||||
public: |
||||
~CodeCompleteResults(); |
||||
CompletionString get(int index); |
||||
int size(); |
||||
CompletionString get(unsigned index); |
||||
unsigned size(); |
||||
|
||||
private: |
||||
CXCodeCompleteResults *results_; |
||||
CXCodeCompleteResults *cx_results; |
||||
}; |
||||
} // namespace clang
|
||||
#endif // CODECOMPLETERESULTS_H_
|
||||
|
||||
@ -1,27 +1,23 @@
|
||||
#include "CompileCommand.h" |
||||
#include "CompileCommands.h" |
||||
|
||||
clang::CompileCommand:: |
||||
CompileCommand(int nth, clang::CompileCommands *commands) { |
||||
command_ = clang_CompileCommands_getCommand(commands->commands_, nth); |
||||
} |
||||
#include "Utility.h" |
||||
|
||||
std::string clang::CompileCommand:: |
||||
get_command() { |
||||
std::string res; |
||||
unsigned N = clang_CompileCommand_getNumArgs(command_); |
||||
for (int i = 0; i < N; i++) { |
||||
res += clang_getCString(clang_CompileCommand_getArg(command_, i)); |
||||
unsigned N = clang_CompileCommand_getNumArgs(cx_command); |
||||
for (unsigned i = 0; i < N; i++) { |
||||
res += clang::to_string(clang_CompileCommand_getArg(cx_command, i)); |
||||
} |
||||
return res; |
||||
} |
||||
|
||||
std::vector<std::string> clang::CompileCommand:: |
||||
get_command_as_args() { |
||||
unsigned N = clang_CompileCommand_getNumArgs(command_); |
||||
unsigned N = clang_CompileCommand_getNumArgs(cx_command); |
||||
std::vector<std::string> res(N); |
||||
for (int i = 0; i < N; i++) { |
||||
res[i] = clang_getCString(clang_CompileCommand_getArg(command_, i)); |
||||
for (unsigned i = 0; i < N; i++) { |
||||
res[i] = clang::to_string(clang_CompileCommand_getArg(cx_command, i)); |
||||
} |
||||
return res; |
||||
} |
||||
|
||||
@ -1,16 +1,17 @@
|
||||
#ifndef COMPILECOMMAND_H_ |
||||
#define COMPILECOMMAND_H_ |
||||
#include "CompilationDatabase.h" |
||||
#include <clang-c/CXCompilationDatabase.h> |
||||
#include <vector> |
||||
#include <string> |
||||
|
||||
namespace clang { |
||||
class CompileCommand { |
||||
public: |
||||
CompileCommand(int nth, CompileCommands *commands); |
||||
CompileCommand(const CXCompileCommand& cx_command) : cx_command(cx_command) {}; |
||||
std::string get_command(); |
||||
std::vector<std::string> get_command_as_args(); |
||||
private: |
||||
CXCompileCommand command_; |
||||
|
||||
CXCompileCommand cx_command; |
||||
}; |
||||
} |
||||
#endif // COMPILECOMMAND_H_
|
||||
|
||||
@ -1,24 +1,24 @@
|
||||
#include "CompileCommands.h" |
||||
|
||||
clang::CompileCommands:: |
||||
CompileCommands(const std::string &filename, CompilationDatabase *db) { |
||||
commands_ = |
||||
clang_CompilationDatabase_getCompileCommands(db->db_, filename.c_str()); |
||||
if(clang_CompileCommands_getSize(commands_)==0) |
||||
commands_ = clang_CompilationDatabase_getAllCompileCommands(db->db_); |
||||
CompileCommands(const std::string &filename, CompilationDatabase &db) { |
||||
cx_commands = |
||||
clang_CompilationDatabase_getCompileCommands(db.cx_db, filename.c_str()); |
||||
if(clang_CompileCommands_getSize(cx_commands)==0) |
||||
cx_commands = clang_CompilationDatabase_getAllCompileCommands(db.cx_db); |
||||
} |
||||
|
||||
clang::CompileCommands:: |
||||
~CompileCommands() { |
||||
clang_CompileCommands_dispose(commands_); |
||||
clang_CompileCommands_dispose(cx_commands); |
||||
} |
||||
|
||||
std::vector<clang::CompileCommand> clang::CompileCommands:: |
||||
get_commands() { |
||||
unsigned N = clang_CompileCommands_getSize(commands_); |
||||
unsigned N = clang_CompileCommands_getSize(cx_commands); |
||||
std::vector<clang::CompileCommand> res; |
||||
for (unsigned i = 0; i < N; i++) { |
||||
res.emplace_back(clang::CompileCommand(i, this)); |
||||
res.emplace_back(clang_CompileCommands_getCommand(cx_commands, i)); |
||||
} |
||||
return res; |
||||
} |
||||
|
||||
@ -1,10 +1,30 @@
|
||||
#include "Cursor.h" |
||||
#include "Utility.h" |
||||
|
||||
const clang::CursorKind clang::Cursor::kind() { |
||||
return (CursorKind) clang_getCursorKind(this->cursor_); |
||||
const clang::CursorKind clang::Cursor::get_kind() { |
||||
return (CursorKind) clang_getCursorKind(this->cx_cursor); |
||||
} |
||||
|
||||
clang::Cursor:: |
||||
Cursor(clang::TranslationUnit *tu, clang::SourceLocation *source_location) { |
||||
cursor_ = clang_getCursor(tu->tu_, source_location->location_); |
||||
clang::SourceLocation clang::Cursor::get_source_location() const { |
||||
return SourceLocation(clang_getCursorLocation(cx_cursor)); |
||||
} |
||||
|
||||
clang::SourceRange clang::Cursor::get_source_range() const { |
||||
return SourceRange(clang_getCursorExtent(cx_cursor)); |
||||
} |
||||
|
||||
std::string clang::Cursor::get_usr() const { |
||||
return clang::to_string(clang_getCursorUSR(cx_cursor)); |
||||
} |
||||
|
||||
clang::Cursor clang::Cursor::get_referenced() const { |
||||
return Cursor(clang_getCursorReferenced(cx_cursor)); |
||||
} |
||||
|
||||
clang::Cursor::operator bool() const { |
||||
return !clang_Cursor_isNull(cx_cursor); |
||||
} |
||||
|
||||
bool clang::Cursor::operator==(const Cursor& rhs) const { |
||||
return get_usr()==rhs.get_usr(); |
||||
} |
||||
@ -1,16 +1,12 @@
|
||||
#ifndef INDEX_H_ |
||||
#define INDEX_H_ |
||||
|
||||
#include <clang-c/Index.h> |
||||
|
||||
namespace clang { |
||||
class TranslationUnit; |
||||
class Index { |
||||
public: |
||||
Index(int excludeDeclarationsFromPCH, int displayDiagnostics); |
||||
private: |
||||
CXIndex index_; |
||||
friend TranslationUnit; |
||||
CXIndex cx_index; |
||||
}; |
||||
} // namespace clang
|
||||
#endif // INDEX_H_
|
||||
|
||||
@ -1,59 +1,34 @@
|
||||
#include "SourceLocation.h" |
||||
#include "Utility.h" |
||||
|
||||
// // // // // // // //
|
||||
// SourceLocation //
|
||||
// // // // // // // //
|
||||
clang::SourceLocation:: |
||||
SourceLocation(clang::TranslationUnit *tu, |
||||
const std::string &filename, |
||||
int line_number, |
||||
int line_offset) { |
||||
CXFile file = clang_getFile(tu->tu_, |
||||
filename.c_str()); |
||||
location_ = clang_getLocation(tu->tu_, |
||||
file, |
||||
line_number, |
||||
line_offset); |
||||
} |
||||
|
||||
clang::SourceLocation:: |
||||
SourceLocation(Cursor *cursor) { |
||||
location_ = clang_getCursorLocation(cursor->cursor_); |
||||
} |
||||
|
||||
clang::SourceLocation:: |
||||
SourceLocation(clang::SourceRange *range, bool start) { |
||||
location_ = start ? clang_getRangeStart(range->range_) : |
||||
clang_getRangeEnd(range->range_); |
||||
clang::SourceLocation::SourceLocation(CXTranslationUnit &tu, const std::string &filepath, unsigned offset) { |
||||
CXFile file = clang_getFile(tu, filepath.c_str()); |
||||
cx_location = clang_getLocationForOffset(tu, file, offset); |
||||
} |
||||
|
||||
clang::SourceLocation:: |
||||
SourceLocation(TranslationUnit *tu, |
||||
Token *token) { |
||||
location_ = clang_getTokenLocation(tu->tu_, |
||||
token->token_); |
||||
std::string clang::SourceLocation::get_path() { |
||||
std::string path; |
||||
get_data(&path, NULL, NULL, NULL); |
||||
return path; |
||||
} |
||||
|
||||
clang::SourceLocation:: |
||||
SourceLocation(clang::TranslationUnit *tu, |
||||
const std::string &filepath, |
||||
int offset) { |
||||
CXFile file = clang_getFile(tu->tu_, |
||||
filepath.c_str()); |
||||
location_ = clang_getLocationForOffset(tu->tu_, |
||||
file, |
||||
offset); |
||||
unsigned clang::SourceLocation::get_offset() { |
||||
unsigned offset; |
||||
get_data(NULL, NULL, NULL, &offset); |
||||
return offset; |
||||
} |
||||
|
||||
void clang::SourceLocation:: |
||||
get_location_info(std::string* path, |
||||
unsigned *line, |
||||
unsigned *column, |
||||
unsigned *offset) { |
||||
CXFile file; |
||||
clang_getExpansionLocation(location_, &file, line, column, offset); |
||||
if (path != NULL && file!=NULL) { |
||||
path->operator=(((clang_getCString((clang_getFileName(file)))))); |
||||
} |
||||
void clang::SourceLocation::get_data(std::string* path, unsigned *line, unsigned *column, unsigned *offset) { |
||||
if(path==nullptr) |
||||
clang_getExpansionLocation(cx_location, NULL, line, column, offset); |
||||
else { |
||||
CXFile file; |
||||
clang_getExpansionLocation(cx_location, &file, line, column, offset); |
||||
if (file!=NULL) { |
||||
*path=clang::to_string(clang_getFileName(file)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
@ -1,15 +1,14 @@
|
||||
#include "SourceRange.h" |
||||
|
||||
clang::SourceRange:: |
||||
SourceRange(clang::TranslationUnit *tu, clang::Token *token) { |
||||
range_ = clang_getTokenExtent(tu->tu_, token->token_); |
||||
SourceRange(clang::SourceLocation &start, clang::SourceLocation &end) { |
||||
cx_range = clang_getRange(start.cx_location, end.cx_location); |
||||
} |
||||
|
||||
clang::SourceRange:: |
||||
SourceRange(clang::SourceLocation *start, clang::SourceLocation *end) { |
||||
range_ = clang_getRange(start->location_, end->location_); |
||||
} |
||||
|
||||
clang::SourceRange::SourceRange(Cursor *cursor) { |
||||
range_ = clang_getCursorExtent(cursor->cursor_); |
||||
} |
||||
std::pair<unsigned, unsigned> clang::SourceRange::get_offsets() { |
||||
SourceLocation start(clang_getRangeStart(cx_range)), end(clang_getRangeEnd(cx_range)); |
||||
std::pair<unsigned, unsigned> offsets; |
||||
offsets.first=start.get_offset(); |
||||
offsets.second=end.get_offset(); |
||||
return offsets; |
||||
} |
||||
@ -1,23 +1,17 @@
|
||||
#ifndef SOURCERANGE_H_ |
||||
#define SOURCERANGE_H_ |
||||
#include "TranslationUnit.h" |
||||
#include "Token.h" |
||||
#include "Cursor.h" |
||||
#include <clang-c/Index.h> |
||||
#include "SourceLocation.h" |
||||
#include <string> |
||||
#include <utility> |
||||
|
||||
namespace clang { |
||||
namespace clang {
|
||||
class SourceRange { |
||||
public: |
||||
SourceRange() {} |
||||
SourceRange(TranslationUnit *tu, Token *token); |
||||
SourceRange(SourceLocation *start, |
||||
SourceLocation *end); |
||||
explicit SourceRange(Cursor *cursor); |
||||
|
||||
private: |
||||
CXSourceRange range_; |
||||
friend Tokens; |
||||
friend SourceLocation; |
||||
friend Diagnostic; |
||||
SourceRange(const CXSourceRange& cx_range) : cx_range(cx_range) {} |
||||
SourceRange(SourceLocation &start, SourceLocation &end); |
||||
std::pair<unsigned, unsigned> get_offsets(); |
||||
CXSourceRange cx_range; |
||||
}; |
||||
} // namespace clang
|
||||
#endif // SOURCERANGE_H_
|
||||
|
||||
@ -1,32 +1,63 @@
|
||||
#include "Token.h" |
||||
#include "Utility.h" |
||||
|
||||
// // // // //
|
||||
// Token //
|
||||
// // // // //
|
||||
|
||||
// clang::Token instansiates an token
|
||||
clang::Token::Token(const CXToken &token) : |
||||
token_(token) { |
||||
} |
||||
|
||||
// returns gets an source location for this token objekt
|
||||
// based on the translationunit given
|
||||
clang::SourceLocation clang::Token:: |
||||
get_source_location(clang::TranslationUnit *tu) { |
||||
return SourceLocation(tu, this); |
||||
clang::SourceLocation clang::Token::get_source_location() { |
||||
return SourceLocation(clang_getTokenLocation(cx_tu, cx_token)); |
||||
} |
||||
|
||||
// returns a sourcerange that covers this token
|
||||
clang::SourceRange clang::Token:: |
||||
get_source_range(clang::TranslationUnit *tu) { |
||||
return SourceRange(tu, this); |
||||
clang::SourceRange clang::Token::get_source_range() { |
||||
return SourceRange(clang_getTokenExtent(cx_tu, cx_token)); |
||||
} |
||||
// returns a string description of this tokens kind
|
||||
std::string clang::Token::get_token_spelling(clang::TranslationUnit *tu) { |
||||
CXString s = clang_getTokenSpelling(tu->tu_, token_); |
||||
return std::string(clang_getCString(s)); |
||||
std::string clang::Token::get_spelling() { |
||||
return clang::to_string(clang_getTokenSpelling(cx_tu, cx_token)); |
||||
} |
||||
|
||||
const clang::TokenKind clang::Token::get_kind() { |
||||
return (TokenKind) clang_getTokenKind(cx_token); |
||||
} |
||||
|
||||
//TODO: Is there a way to optimise this?
|
||||
bool clang::Token::has_type() { |
||||
auto referenced=clang_getCursorReferenced(cx_cursor); |
||||
if(clang_Cursor_isNull(referenced)) |
||||
return false; |
||||
auto type=clang_getCursorType(referenced); |
||||
auto spelling=clang::to_string(clang_getTypeSpelling(type)); |
||||
return spelling!=""; |
||||
} |
||||
|
||||
std::string clang::Token::get_type() { |
||||
std::string spelling; |
||||
auto referenced=clang_getCursorReferenced(cx_cursor); |
||||
if(!clang_Cursor_isNull(referenced)) { |
||||
auto type=clang_getCursorType(referenced); |
||||
spelling=clang::to_string(clang_getTypeSpelling(type)); |
||||
std::string auto_end=""; |
||||
//TODO fix const auto
|
||||
if((spelling.size()>=4 && spelling.substr(0, 4)=="auto")) { |
||||
auto_end=spelling.substr(4); |
||||
auto type=clang_getCanonicalType(clang_getCursorType(cx_cursor)); |
||||
spelling=clang::to_string(clang_getTypeSpelling(type)); |
||||
if(spelling.find(" ")==std::string::npos) |
||||
spelling+=auto_end; |
||||
} |
||||
} |
||||
return spelling; |
||||
} |
||||
|
||||
const clang::TokenKind clang::Token::kind() { |
||||
return (TokenKind) clang_getTokenKind(token_); |
||||
std::string clang::Token::get_brief_comments() { |
||||
std::string comment_string; |
||||
auto referenced=get_cursor().get_referenced(); |
||||
if(referenced) { |
||||
comment_string=clang::to_string(clang_Cursor_getBriefCommentText(referenced.cx_cursor)); |
||||
} |
||||
return comment_string; |
||||
} |
||||
|
||||
@ -1,136 +1,69 @@
|
||||
#include "Tokens.h" |
||||
#include "Utility.h" |
||||
#include <iostream> |
||||
using namespace std; |
||||
|
||||
clang::Tokens::Tokens(clang::TranslationUnit *tu, clang::SourceRange *range): tu(*tu) { |
||||
clang_tokenize(tu->tu_, |
||||
range->range_, |
||||
&tokens_, |
||||
&num_tokens_); |
||||
for (int i = 0; i < num_tokens_; i++) { |
||||
push_back(clang::Token(tokens_[i])); |
||||
clang::Tokens::Tokens(CXTranslationUnit &cx_tu, const SourceRange &range): cx_tu(cx_tu) { |
||||
clang_tokenize(cx_tu, range.cx_range, &cx_tokens, &num_tokens); |
||||
cx_cursors.clear(); |
||||
cx_cursors.resize(num_tokens); |
||||
clang_annotateTokens(cx_tu, cx_tokens, num_tokens, cx_cursors.data()); |
||||
for (unsigned i = 0; i < num_tokens; i++) { |
||||
emplace_back(Token(cx_tu, cx_tokens[i], cx_cursors[i])); |
||||
} |
||||
} |
||||
|
||||
clang::Tokens::~Tokens() { |
||||
clang_disposeTokens(tu.tu_, tokens_, size()); |
||||
clang_disposeTokens(cx_tu, cx_tokens, size()); |
||||
} |
||||
|
||||
void clang::Tokens::update_types(clang::TranslationUnit *tu) { |
||||
clang_cursors.clear(); |
||||
clang_cursors.reserve(size()); |
||||
clang_annotateTokens(tu->tu_, tokens_, size(), clang_cursors.data()); |
||||
|
||||
for(size_t c=0;c<size();c++) { |
||||
auto referenced=clang_getCursorReferenced(clang_cursors[c]); |
||||
if(!clang_Cursor_isNull(referenced)) { |
||||
auto type=clang_getCursorType(referenced); |
||||
auto cxstr=clang_getTypeSpelling(type); |
||||
std::string spelling=clang_getCString(cxstr); |
||||
clang_disposeString(cxstr); |
||||
std::string auto_end=""; |
||||
//TODO fix const auto
|
||||
if((spelling.size()>=4 && spelling.substr(0, 4)=="auto")) { |
||||
auto_end=spelling.substr(4); |
||||
auto type=clang_getCanonicalType(clang_getCursorType(clang_cursors[c])); |
||||
auto cxstr=clang_getTypeSpelling(type); |
||||
spelling=clang_getCString(cxstr); |
||||
clang_disposeString(cxstr); |
||||
if(spelling.find(" ")==std::string::npos) |
||||
spelling+=auto_end; |
||||
//This works across TranslationUnits! However, to get rename refactoring to work,
|
||||
//one have to open all the files that might include a similar token
|
||||
//Similar tokens defined as tokens with equal referenced cursors.
|
||||
std::vector<std::pair<unsigned, unsigned> > clang::Tokens::get_similar_token_offsets(const std::string &usr) { |
||||
std::vector<std::pair<unsigned, unsigned> > offsets; |
||||
for(auto &token: *this) { |
||||
if(token.get_kind()==clang::Token_Identifier) { |
||||
auto referenced=token.get_cursor().get_referenced(); |
||||
if(referenced && usr==referenced.get_usr()) { |
||||
offsets.emplace_back(token.offsets); |
||||
} |
||||
|
||||
(*this)[c].type=spelling; |
||||
//std::cout << clang_getCString(clang_getTypeSpelling(type)) << ": " << type.kind << endl;
|
||||
////auto cursor=clang_getTypeDeclaration(type);
|
||||
////tks[c].type=clang_getCString(clang_getCursorSpelling(cursor));
|
||||
////auto type=clang_getCursorType(referenced);
|
||||
|
||||
} |
||||
//Testing:
|
||||
/*if(tks[c].get_token_spelling(tu)=="text_view") {
|
||||
cout << tks[c].get_token_spelling(tu) << endl; |
||||
auto kind=clang_getCursorKind(cursors[c].cursor_); |
||||
cout << " " << kind << endl; |
||||
cout << " Decl: " << clang_isDeclaration(kind) << endl; |
||||
cout << " Attr: " << clang_isAttribute(kind) << endl; |
||||
cout << " Ref: " << clang_isReference(kind) << endl; |
||||
cout << " Expr: " << clang_isExpression(kind) << endl; |
||||
auto referenced=clang_getCursorReferenced(cursors[c].cursor_); |
||||
if(!clang_Cursor_isNull(referenced)) { |
||||
cout << " " << clang_getCursorKind(referenced) << endl; |
||||
|
||||
clang::Cursor referenced_cursor; |
||||
referenced_cursor.cursor_=referenced; |
||||
auto range=clang::SourceRange(&referenced_cursor); |
||||
|
||||
auto location=clang::SourceLocation(&range, true); |
||||
std::string path; |
||||
unsigned line, column, offset; |
||||
location.get_location_info(&path, &line, &column, &offset); |
||||
cout << " start: " << path << ", " << line << ", " << column << endl; |
||||
|
||||
location=clang::SourceLocation(&range, false); |
||||
location.get_location_info(&path, &line, &column, &offset); |
||||
cout << " start: " << path << ", " << line << ", " << column << endl; |
||||
|
||||
auto type=clang_getCursorType(referenced); |
||||
cout << " " << clang_getCString(clang_getTypeSpelling(type)) << endl; |
||||
} |
||||
}*/ |
||||
} |
||||
return offsets; |
||||
} |
||||
|
||||
std::string clang::Tokens::get_brief_comments(size_t cursor_id) { |
||||
std::string comment_string; |
||||
auto referenced=clang_getCursorReferenced(clang_cursors[cursor_id]); |
||||
auto comment=clang_Cursor_getParsedComment(referenced); |
||||
if(clang_Comment_getKind(comment)==CXComment_FullComment) { |
||||
size_t para_c=0; |
||||
for(unsigned c=0;c<clang_Comment_getNumChildren(comment);c++) { |
||||
auto child_comment=clang_Comment_getChild(comment, c); |
||||
if(clang_Comment_getKind(child_comment)==CXComment_Paragraph) { |
||||
para_c++; |
||||
if(para_c>=2) |
||||
break; |
||||
for(unsigned c=0;c<clang_Comment_getNumChildren(child_comment);c++) { |
||||
auto grandchild_comment=clang_Comment_getChild(child_comment, c); |
||||
if(clang_Comment_getKind(grandchild_comment)==CXComment_Text) { |
||||
auto cxstr=clang_TextComment_getText(grandchild_comment); |
||||
comment_string+=clang_getCString(cxstr); |
||||
comment_string+="\n"; |
||||
clang_disposeString(cxstr); |
||||
size_t dot_position=comment_string.find("."); |
||||
if(dot_position!=std::string::npos) |
||||
return comment_string.substr(0, dot_position); |
||||
} |
||||
if(clang_Comment_getKind(grandchild_comment)==CXComment_InlineCommand) { |
||||
auto cxstr=clang_InlineCommandComment_getCommandName(grandchild_comment); |
||||
if(comment_string.size()>0) |
||||
comment_string.pop_back(); |
||||
if(clang_InlineCommandComment_getNumArgs(grandchild_comment)==0) |
||||
comment_string+=clang_getCString(cxstr); |
||||
clang_disposeString(cxstr); |
||||
for(unsigned arg_c=0;arg_c<clang_InlineCommandComment_getNumArgs(grandchild_comment);arg_c++) { |
||||
auto cxstr=clang_InlineCommandComment_getArgText(grandchild_comment, arg_c); |
||||
if(cxstr.data!=NULL) { |
||||
if(arg_c>0) |
||||
comment_string+=" "; |
||||
comment_string+=clang_getCString(cxstr); |
||||
clang_disposeString(cxstr); |
||||
} |
||||
} |
||||
std::vector<std::pair<std::string, unsigned> > clang::Tokens::get_cxx_methods() { |
||||
std::vector<std::pair<std::string, unsigned> > methods; |
||||
long last_offset=-1; |
||||
for(auto &token: *this) { |
||||
if(token.get_kind()==clang::Token_Identifier) { |
||||
auto cursor=token.get_cursor(); |
||||
auto kind=cursor.get_kind(); |
||||
if(kind==clang::CursorKind::CXXMethod || kind==clang::CursorKind::Constructor || kind==clang::CursorKind::Destructor) { |
||||
auto offset=cursor.get_source_location().get_offset(); |
||||
if(offset!=last_offset) { |
||||
std::string method; |
||||
if(kind==clang::CursorKind::CXXMethod) { |
||||
auto type=clang_getResultType(clang_getCursorType(cursor.cx_cursor)); |
||||
method+=clang::to_string(clang_getTypeSpelling(type)); |
||||
auto pos=method.find(" "); |
||||
if(pos!=std::string::npos) |
||||
method.erase(pos, 1); |
||||
method+=" "; |
||||
} |
||||
|
||||
clang::Cursor parent(clang_getCursorSemanticParent(cursor.cx_cursor)); |
||||
method+=clang::to_string(clang_getCursorDisplayName(parent.cx_cursor)); |
||||
|
||||
method+="::"; |
||||
|
||||
method+=clang::to_string(clang_getCursorDisplayName(cursor.cx_cursor)); |
||||
methods.emplace_back(method, offset); |
||||
} |
||||
last_offset=offset; |
||||
} |
||||
/*cout << " " << clang_Comment_getKind(child_comment) << ", children: " << clang_Comment_getNumChildren(child_comment) << endl;
|
||||
auto cxstr=clang_FullComment_getAsHTML(child_comment); |
||||
cout << " " << clang_getCString(cxstr) << endl; |
||||
clang_disposeString(cxstr);*/ |
||||
} |
||||
while(comment_string.size()>0 && (comment_string.back()=='\n' || comment_string.back()==' ')) |
||||
comment_string.pop_back(); |
||||
} |
||||
|
||||
return comment_string; |
||||
} |
||||
return methods; |
||||
} |
||||
|
||||
@ -1,21 +1,25 @@
|
||||
#ifndef TOKENS_H_ |
||||
#define TOKENS_H_ |
||||
#include "TranslationUnit.h" |
||||
#include <clang-c/Index.h> |
||||
#include "SourceRange.h" |
||||
#include "Token.h" |
||||
#include <unordered_map> |
||||
#include <vector> |
||||
|
||||
namespace clang { |
||||
class Tokens : public std::vector<clang::Token> { |
||||
friend class TranslationUnit; |
||||
friend class Diagnostic; |
||||
Tokens(CXTranslationUnit &cx_tu, const SourceRange &range); |
||||
public: |
||||
Tokens(TranslationUnit *tu, SourceRange *range); |
||||
~Tokens(); |
||||
void update_types(clang::TranslationUnit *tu); |
||||
std::string get_brief_comments(size_t cursor_id); |
||||
std::vector<std::pair<unsigned, unsigned> > get_similar_token_offsets(const std::string &usr); |
||||
std::vector<std::pair<std::string, unsigned> > get_cxx_methods(); |
||||
private: |
||||
CXToken *tokens_; |
||||
unsigned num_tokens_; |
||||
std::vector<CXCursor> clang_cursors; |
||||
TranslationUnit& tu; |
||||
CXToken *cx_tokens; |
||||
unsigned num_tokens; |
||||
std::vector<CXCursor> cx_cursors; |
||||
CXTranslationUnit& cx_tu; |
||||
}; |
||||
} // namespace clang
|
||||
#endif // TOKENS_H_
|
||||
|
||||
@ -0,0 +1,10 @@
|
||||
#include "Utility.h" |
||||
|
||||
std::string clang::to_string(CXString cx_string) { |
||||
std::string string; |
||||
if(cx_string.data!=NULL) { |
||||
string=clang_getCString(cx_string); |
||||
clang_disposeString(cx_string); |
||||
} |
||||
return string; |
||||
} |
||||
@ -0,0 +1,10 @@
|
||||
#ifndef UTILITY_H_ |
||||
#define UTILITY_H_ |
||||
#include <clang-c/Index.h> |
||||
#include <string> |
||||
|
||||
namespace clang { |
||||
std::string to_string(CXString cx_string); |
||||
} |
||||
|
||||
#endif // UTILITY_H_
|
||||
@ -0,0 +1,13 @@
|
||||
# Windows Install Guide # |
||||
## Requirements ## |
||||
|
||||
```bash |
||||
* chocolatey [website](http://chocolatey.org) |
||||
``` |
||||
|
||||
##Preperation ## |
||||
First you install some dependencies |
||||
|
||||
```bash |
||||
PS: choco install cmake make nmake |
||||
``` |
||||
Loading…
Reference in new issue