zalox
/
jucipp
mirror of https://gitlab.com/cppit/jucipp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #9 from eidheim/master 

Fixed threading crash
merge-requests/365/head
Jørgen Lien Sellæg 11 years ago
parent
53ac248664 a2f68575c9
commit
f20cfd927f
5 changed files with 228 additions and 302 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      juci/config.cc
  2. 86
      juci/notebook.cc
  3. 3
      juci/notebook.h
  4. 295
      juci/source.cc
  5. 126
      juci/source.h

6
juci/config.cc
Unescape View File

@ -39,13 +39,13 @@ void MainConfig::GenerateSource() {
source_cfg.tab+=" ";
}
for (auto &i : colors_json) {
source_cfg.InsertTag(i.first, i.second.get_value<std::string>());
source_cfg.tags[i.first]=i.second.get_value<std::string>();
}
for (auto &i : syntax_json) {
source_cfg.InsertType(i.first, i.second.get_value<std::string>());
source_cfg.types[i.first]=i.second.get_value<std::string>();
}
for (auto &i : extensions_json) {
source_cfg.InsertExtension(i.second.get_value<std::string>());
source_cfg.extensions.emplace_back(i.second.get_value<std::string>());
}
DEBUG("Source cfg fetched");
}

86
juci/notebook.cc
Unescape View File

@ -18,8 +18,7 @@ Notebook::Controller::Controller(Gtk::Window* window,
Source::Config& source_cfg,
Directories::Config& dir_cfg) :
directories_(dir_cfg),
source_config_(source_cfg),
index_(0, 1) {
source_config_(source_cfg) {
INFO("Create notebook");
window_ = window;
OnNewPage("untitled");
@ -193,7 +192,7 @@ bool Notebook::Controller::OnKeyRelease(GdkEventKey* key) {
bool Notebook::Controller::GeneratePopup(int key_id) {
INFO("Notebook genereate popup, getting iters");
std::string path = text_vec_.at(CurrentPage())->parser.file_path;
if (!LegalExtension(path.substr(path.find_last_of(".") + 1))) return false;
if (!source_config().legal_extension(path.substr(path.find_last_of(".") + 1))) return false;
// Get function to fill popup with suggests item vector under is for testing
Gtk::TextIter beg = CurrentTextView().get_buffer()->get_insert()->get_iter();
Gtk::TextIter end = CurrentTextView().get_buffer()->get_insert()->get_iter();
@ -230,22 +229,20 @@ bool Notebook::Controller::GeneratePopup(int key_id) {
return false;
}
INFO("Notebook genereate popup, getting autocompletions");
std::vector<Source::AutoCompleteData> acdata;
text_vec_.at(CurrentPage())->
GetAutoCompleteSuggestions(beg.get_line()+1,
beg.get_line_offset()+2,
&acdata);
std::vector<Source::AutoCompleteData> acdata=text_vec_.at(CurrentPage())->parser.
get_autocomplete_suggestions(beg.get_line()+1,
beg.get_line_offset()+2);
std::map<std::string, std::string> items;
for (auto &data : acdata) {
std::stringstream ss;
std::string return_value;
for (auto &chunk : data.chunks_) {
switch (chunk.kind()) {
for (auto &chunk : data.chunks) {
switch (chunk.kind) {
case clang::CompletionChunk_ResultType:
return_value = chunk.chunk();
return_value = chunk.chunk;
break;
case clang::CompletionChunk_Informative: break;
default: ss << chunk.chunk(); break;
default: ss << chunk.chunk; break;
}
}
if (ss.str().length() > 0) { // if length is 0 the result is empty
@ -304,7 +301,7 @@ Gtk::Box& Notebook::Controller::entry_view() {
void Notebook::Controller::OnNewPage(std::string name) {
INFO("Notebook Generate new page");
OnCreatePage();
text_vec_.back()->OnNewEmptyFile();
text_vec_.back()->on_new_empty_file();
Notebook().append_page(*editor_vec_.back(), name);
Notebook().show_all_children();
Notebook().set_current_page(Pages()-1);
@ -312,21 +309,15 @@ void Notebook::Controller::OnNewPage(std::string name) {
}
void Notebook::Controller::
MapBuffers(std::map<std::string, std::string> *buffers) const {
for (auto &buffer : text_vec_) {
buffers->operator[](buffer->parser.file_path) =
buffer->buffer()->get_text().raw();
}
}
void Notebook::Controller::OnOpenFile(std::string path) {
INFO("Notebook open file");
OnCreatePage();
text_vec_.back()->OnOpenFile(path);
text_vec_.back()->is_saved=true;
unsigned pos = path.find_last_of("/\\");
Notebook().append_page(*editor_vec_.back(), path.substr(pos+1));
text_vec_.back()->on_open_file(path);
size_t pos = path.find_last_of("/\\");
std::string filename=path;
if(pos!=std::string::npos)
filename=path.substr(pos+1);
Notebook().append_page(*editor_vec_.back(), filename);
Notebook().show_all_children();
Notebook().set_current_page(Pages()-1);
Notebook().set_focus_child(text_vec_.back()->view);
@ -334,18 +325,29 @@ void Notebook::Controller::OnOpenFile(std::string path) {
void Notebook::Controller::OnCreatePage() {
INFO("Notebook create page");
text_vec_.emplace_back(new Source::Controller(source_config(), *this));
text_vec_.emplace_back(new Source::Controller(source_config(), text_vec_));
scrolledtext_vec_.push_back(new Gtk::ScrolledWindow());
editor_vec_.push_back(new Gtk::HBox());
scrolledtext_vec_.back()->add(text_vec_.back()->view);
editor_vec_.back()->pack_start(*scrolledtext_vec_.back(), true, true);
TextViewHandlers(text_vec_.back()->view);
//Add star on tab label when the page is not saved:
text_vec_.back()->signal_buffer_changed=[this](bool was_saved) {
if(was_saved) {
std::string path=text_vec_.at(CurrentPage())->parser.file_path;
size_t pos = path.find_last_of("/\\");
std::string filename=path;
if(pos!=std::string::npos)
filename=path.substr(pos+1);
Notebook().set_tab_label_text(*Notebook().get_nth_page(CurrentPage()), filename+"*");
}
};
}
void Notebook::Controller::OnCloseCurrentPage() {
INFO("Notebook close page");
if (Pages() != 0) {
if(text_vec_.back()->is_changed){
if(!text_vec_.back()->is_saved){
AskToSaveDialog();
}
int page = CurrentPage();
@ -581,17 +583,8 @@ void Notebook::Controller::FindPopupPosition(Gtk::TextView& textview,
}
bool Notebook::Controller:: OnSaveFile() {
INFO("Notebook save file");
if (text_vec_.at(CurrentPage())->is_saved) {
std::ofstream file;
file.open (text_vec_.at(CurrentPage())->parser.file_path);
file << CurrentTextView().get_buffer()->get_text();
file.close();
return true;
} else {
return OnSaveFile(OnSaveFileAs());
}
return false;
std::string path=text_vec_.at(CurrentPage())->parser.file_path;
return OnSaveFile(path);
}
bool Notebook::Controller:: OnSaveFile(std::string path) {
INFO("Notebook save file with path");
@ -601,6 +594,11 @@ bool Notebook::Controller:: OnSaveFile(std::string path) {
file << CurrentTextView().get_buffer()->get_text();
file.close();
text_vec_.at(CurrentPage())->parser.file_path=path;
size_t pos = path.find_last_of("/\\");
std::string filename=path;
if(pos!=std::string::npos)
filename=path.substr(pos+1);
Notebook().set_tab_label_text(*Notebook().get_nth_page(CurrentPage()), filename);
text_vec_.at(CurrentPage())->is_saved=true;
return true;
}
@ -674,15 +672,3 @@ void Notebook::Controller::AskToSaveDialog() {
}
}
bool Notebook::Controller::LegalExtension(std::string e) {
std::transform(e.begin(), e.end(),e.begin(), ::tolower);
std::vector<std::string> extensions =
source_config().extensiontable();
if (find(extensions.begin(), extensions.end(), e) != extensions.end()) {
DEBUG("Legal extension");
return true;
}
DEBUG("Ilegal extension");
return false;
}

3
juci/notebook.h
Unescape View File

@ -62,8 +62,6 @@ namespace Notebook {
void OnOpenFile(std::string filename);
void OnCreatePage();
bool ScrollEventCallback(GdkEventScroll* scroll_event);
void MapBuffers(std::map<std::string, std::string> *buffers) const;
clang::Index* index() { return &index_; }
int Pages();
Directories::Controller& directories() { return directories_; }
Gtk::Paned& view();
@ -111,7 +109,6 @@ namespace Notebook {
bool ispopup;
Gtk::Dialog popup_;
Gtk::Window* window_;
clang::Index index_;
}; // class controller
} // namespace Notebook
#endif // JUCI_NOTEBOOK_H_

295
juci/source.cc
Unescape View File

@ -3,27 +3,19 @@
#include <boost/property_tree/json_parser.hpp>
#include <fstream>
#include <boost/timer/timer.hpp>
#include "notebook.h"
#include "logging.h"
#include <algorithm>
#include <regex>
Source::Location::
Location(int line_number, int column_offset) :
line_number_(line_number), column_offset_(column_offset) { }
Source::Location::
Location(const Source::Location &org) :
line_number_(org.line_number_), column_offset_(org.column_offset_) { }
Source::Range::
Range(const Location &start, const Location &end, int kind) :
start_(start), end_(end), kind_(kind) { }
Source::Range::
Range(const Source::Range &org) :
start_(org.start_), end_(org.end_), kind_(org.kind_) { }
bool Source::Config::legal_extension(std::string e) const {
std::transform(e.begin(), e.end(),e.begin(), ::tolower);
if (find(extensions.begin(), extensions.end(), e) != extensions.end()) {
DEBUG("Legal extension");
return true;
}
DEBUG("Ilegal extension");
return false;
}
//////////////
//// View ////
@ -32,7 +24,7 @@ Source::View::View() {
Gsv::init();
}
string Source::View::GetLine(size_t line_number) {
string Source::View::get_line(size_t line_number) {
Gtk::TextIter line_it = get_source_buffer()->get_iter_at_line(line_number);
Gtk::TextIter line_end_it = line_it;
while(!line_end_it.ends_line())
@ -41,59 +33,25 @@ string Source::View::GetLine(size_t line_number) {
return line;
}
string Source::View::GetLineBeforeInsert() {
string Source::View::get_line_before_insert() {
Gtk::TextIter insert_it = get_source_buffer()->get_insert()->get_iter();
Gtk::TextIter line_it = get_source_buffer()->get_iter_at_line(insert_it.get_line());
std::string line(get_source_buffer()->get_text(line_it, insert_it));
return line;
}
// Source::View::Config::tagtable()
// returns a const refrence to the tagtable
const std::unordered_map<string, string>& Source::Config::tagtable() const {
return tagtable_;
}
// Source::View::Config::tagtable()
// returns a const refrence to the tagtable
const std::unordered_map<string, string>& Source::Config::typetable() const {
return typetable_;
}
std::vector<string>& Source::Config::extensiontable(){
return extensiontable_;
}
void Source::Config::InsertTag(const string &key, const string &value) {
tagtable_[key] = value;
}
void Source::Config::InsertExtension(const string &ext) {
extensiontable_.push_back(ext);
}
// Source::View::Config::SetTagTable()
// sets the tagtable for the view
void Source::Config::
SetTypeTable(const std::unordered_map<string, string> &typetable) {
typetable_ = typetable;
}
///////////////
//// Parser ///
///////////////
clang::Index Source::Parser::clang_index(0, 1);
void Source::Config::InsertType(const string &key, const string &value) {
typetable_[key] = value;
}
// Source::View::Config::SetTagTable()
// sets the tagtable for the view
void Source::Config::
SetTagTable(const std::unordered_map<string, string> &tagtable) {
tagtable_ = tagtable;
Source::Parser::~Parser() {
parsing_mutex.lock(); //Be sure not to destroy while still parsing with libclang
parsing_mutex.unlock();
}
///////////////
//// Model ////
///////////////
void Source::Parser::
InitSyntaxHighlighting(const std::string &filepath,
init_syntax_highlighting(const std::string &filepath,
const std::string &project_path,
const std::map<std::string, std::string>
&buffers,
@ -108,51 +66,32 @@ InitSyntaxHighlighting(const std::string &filepath,
buffers));
}
// Source::View::UpdateLine
void Source::View::
OnLineEdit(const std::vector<Source::Range> &locations,
const Source::Config &config) {
OnUpdateSyntax(locations, config);
std::map<std::string, std::string> Source::Parser::
get_buffer_map() const {
std::map<std::string, std::string> buffer_map;
for (auto &controller : controllers) {
buffer_map.operator[](controller->parser.file_path) =
controller->buffer()->get_text().raw();
}
return buffer_map;
}
// Source::Model::UpdateLine
int Source::Parser::
ReParse(const std::map<std::string, std::string> &buffer) {
reparse(const std::map<std::string, std::string> &buffer) {
return tu_->ReparseTranslationUnit(file_path, buffer);
}
// Source::Controller::OnLineEdit()
// fired when a line in the buffer is edited
void Source::Controller::OnLineEdit() { }
void Source::Controller::
GetAutoCompleteSuggestions(int line_number,
int column,
std::vector<Source::AutoCompleteData>
*suggestions) {
std::vector<Source::AutoCompleteData> Source::Parser::
get_autocomplete_suggestions(int line_number,
int column) {
INFO("Getting auto complete suggestions");
parsing.lock();
std::map<std::string, std::string> buffers;
notebook.MapBuffers(&buffers);
parser.GetAutoCompleteSuggestions(buffers,
line_number,
column,
suggestions);
DEBUG("Number of suggestions");
DEBUG_VAR(suggestions->size());
parsing.unlock();
}
void Source::Parser::
GetAutoCompleteSuggestions(const std::map<std::string, std::string> &buffers,
int line_number,
int column,
std::vector<Source::AutoCompleteData>
*suggestions) {
std::vector<Source::AutoCompleteData> suggestions;
auto buffer_map=get_buffer_map();
parsing_mutex.lock();
clang::CodeCompleteResults results(tu_.get(),
file_path,
buffers,
buffer_map,
line_number,
column);
for (int i = 0; i < results.size(); i++) {
@ -161,8 +100,12 @@ GetAutoCompleteSuggestions(const std::map<std::string, std::string> &buffers,
for (auto &chunk : chunks_) {
chunks.emplace_back(chunk);
}
suggestions->emplace_back(chunks);
suggestions.emplace_back(chunks);
}
parsing_mutex.unlock();
DEBUG("Number of suggestions");
DEBUG_VAR(suggestions.size());
return suggestions;
}
std::vector<std::string> Source::Parser::
@ -181,7 +124,7 @@ get_compilation_commands() {
}
std::vector<Source::Range> Source::Parser::
ExtractTokens(int start_offset, int end_offset) {
extract_tokens(int start_offset, int end_offset) {
std::vector<Source::Range> ranges;
clang::SourceLocation start(tu_.get(), file_path, start_offset);
clang::SourceLocation end(tu_.get(), file_path, end_offset);
@ -190,18 +133,18 @@ ExtractTokens(int start_offset, int end_offset) {
std::vector<clang::Token> tks = tokens.tokens();
for (auto &token : tks) {
switch (token.kind()) {
case 0: HighlightCursor(&token, &ranges); break; // PunctuationToken
case 1: HighlightToken(&token, &ranges, 702); break; // KeywordToken
case 2: HighlightCursor(&token, &ranges); break; // IdentifierToken
case 3: HighlightToken(&token, &ranges, 109); break; // LiteralToken
case 4: HighlightToken(&token, &ranges, 705); break; // CommentToken
case 0: highlight_cursor(&token, &ranges); break; // PunctuationToken
case 1: highlight_token(&token, &ranges, 702); break; // KeywordToken
case 2: highlight_cursor(&token, &ranges); break; // IdentifierToken
case 3: highlight_token(&token, &ranges, 109); break; // LiteralToken
case 4: highlight_token(&token, &ranges, 705); break; // CommentToken
}
}
return ranges;
}
void Source::Parser::
HighlightCursor(clang::Token *token,
highlight_cursor(clang::Token *token,
std::vector<Source::Range> *source_ranges) {
clang::SourceLocation location = token->get_source_location(tu_.get());
clang::Cursor cursor(tu_.get(), &location);
@ -217,7 +160,7 @@ HighlightCursor(clang::Token *token,
end_offset), (int) cursor.kind());
}
void Source::Parser::
HighlightToken(clang::Token *token,
highlight_token(clang::Token *token,
std::vector<Source::Range> *source_ranges,
int token_kind) {
clang::SourceRange range = token->get_source_range(tu_.get());
@ -239,51 +182,50 @@ HighlightToken(clang::Token *token,
// Source::Controller::Controller()
// Constructor for Controller
Source::Controller::Controller(const Source::Config &config,
Notebook::Controller &notebook) :
config(config), notebook(notebook) {
const std::vector<std::unique_ptr<Source::Controller> > &controllers) :
config(config), parser(controllers), parse_thread_go(false), parse_thread_mapped(false), parse_thread_stop(false) {
INFO("Source Controller with childs constructed");
view.signal_key_press_event().connect(sigc::mem_fun(*this, &Source::Controller::OnKeyPress), false);
view.signal_key_press_event().connect(sigc::mem_fun(*this, &Source::Controller::on_key_press), false);
view.set_smart_home_end(Gsv::SMART_HOME_END_BEFORE);
view.override_font(Pango::FontDescription(config.font));
view.set_show_line_numbers(config.show_line_numbers);
view.set_highlight_current_line(config.highlight_current_line);
view.override_background_color(Gdk::RGBA(config.background));
for (auto &item : config.tagtable()) {
for (auto &item : config.tags) {
buffer()->create_tag(item.first)->property_foreground() = item.second;
}
buffer()->signal_changed().connect([this]() {
if(signal_buffer_changed)
signal_buffer_changed(is_saved);
is_saved=false;
parse_thread_mapped=false;
parse_thread_go=true;
});
}
Source::Controller::~Controller() {
parsing.lock(); //Be sure not to destroy while still parsing with libclang
parsing.unlock();
parse_thread_stop=true;
if(parse_thread.joinable())
parse_thread.join();
}
void Source::Controller::OnNewEmptyFile() {
string filename("/tmp/juci_t");
sourcefile s(filename);
parser.file_path=filename;
parser.project_path=filename;
s.save("");
}
void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
const Source::Config &config) {
void Source::Controller::update_syntax(const std::vector<Source::Range> &ranges) {
if (ranges.empty() || ranges.size() == 0) {
return;
}
Glib::RefPtr<Gtk::TextBuffer> buffer = get_buffer();
auto buffer = view.get_buffer();
buffer->remove_all_tags(buffer->begin(), buffer->end());
for (auto &range : ranges) {
std::string type = std::to_string(range.kind());
std::string type = std::to_string(range.kind);
try {
config.typetable().at(type);
config.types.at(type);
} catch (std::exception) {
continue;
}
int linum_start = range.start().line_number()-1;
int linum_end = range.end().line_number()-1;
int begin = range.start().column_offset()-1;
int end = range.end().column_offset()-1;
int linum_start = range.start.line_number-1;
int linum_end = range.end.line_number-1;
int begin = range.start.column_offset-1;
int end = range.end.column_offset-1;
if (end < 0) end = 0;
if (begin < 0) begin = 0;
@ -291,61 +233,80 @@ void Source::View::OnUpdateSyntax(const std::vector<Source::Range> &ranges,
buffer->get_iter_at_line_offset(linum_start, begin);
Gtk::TextIter end_iter =
buffer->get_iter_at_line_offset(linum_end, end);
buffer->apply_tag_by_name(config.typetable().at(type),
buffer->apply_tag_by_name(config.types.at(type),
begin_iter, end_iter);
}
}
void Source::Controller::OnOpenFile(const string &filepath) {
void Source::Controller::on_new_empty_file() {
string filename("/tmp/untitled");
sourcefile s(filename);
parser.file_path=filename;
parser.project_path=filename;
s.save("");
}
void Source::Controller::on_open_file(const string &filepath) {
parser.file_path=filepath;
sourcefile s(filepath);
std::map<std::string, std::string> buffers;
notebook.MapBuffers(&buffers);
buffers[filepath] = s.get_content();
auto buffer_map=parser.get_buffer_map();
buffer_map[filepath] = s.get_content();
buffer()->get_undo_manager()->begin_not_undoable_action();
buffer()->set_text(s.get_content());
is_saved=true;
buffer()->get_undo_manager()->end_not_undoable_action();
int start_offset = buffer()->begin().get_offset();
int end_offset = buffer()->end().get_offset();
if (notebook.LegalExtension(filepath.substr(filepath.find_last_of(".") + 1))) {
parser.InitSyntaxHighlighting(filepath,
if (config.legal_extension(filepath.substr(filepath.find_last_of(".") + 1))) {
parser.init_syntax_highlighting(filepath,
parser.file_path.substr(0, parser.file_path.find_last_of('/')),
buffers,
buffer_map,
start_offset,
end_offset,
notebook.index());
view.OnUpdateSyntax(parser.ExtractTokens(start_offset, end_offset), config);
&Parser::clang_index);
update_syntax(parser.extract_tokens(start_offset, end_offset));
//GTK-calls must happen in main thread, so the parse_thread
//sends signals to the main thread that it is to call the following functions:
parse_start.connect([this]{
if(parse_thread_buffer_map_mutex.try_lock()) {
this->parse_thread_buffer_map=parser.get_buffer_map();
parse_thread_mapped=true;
parse_thread_buffer_map_mutex.unlock();
}
parse_thread_go=true;
});
//OnUpdateSyntax must happen in main thread, so the parse-thread
//sends a signal to the main thread that it is to call the following function:
parsing_done.connect([this](){
parse_done.connect([this](){
if(parse_thread_mapped) {
INFO("Updating syntax");
view.
OnUpdateSyntax(parser.ExtractTokens(0, buffer()->get_text().size()), config);
update_syntax(parser.extract_tokens(0, buffer()->get_text().size()));
INFO("Syntax updated");
}
else {
parse_thread_go=true;
}
});
buffer()->signal_end_user_action().connect([this]() {
std::thread parse([this]() {
if (parsing.try_lock()) {
INFO("Starting parsing");
while (true) {
const std::string raw = buffer()->get_text().raw();
std::map<std::string, std::string> buffers;
notebook.MapBuffers(&buffers);
buffers[parser.file_path] = raw;
if (parser.ReParse(buffers) == 0 &&
raw == buffer()->get_text().raw()) {
parse_thread=std::thread([this]() {
while(true) {
while(!parse_thread_go && !parse_thread_stop)
std::this_thread::sleep_for(std::chrono::milliseconds(10));
if(parse_thread_stop)
break;
if(!parse_thread_mapped) {
parse_thread_go=false;
parse_start();
}
else if (parse_thread_mapped && parser.parsing_mutex.try_lock() && parse_thread_buffer_map_mutex.try_lock()) {
parser.reparse(this->parse_thread_buffer_map);
parse_thread_go=false;
parser.parsing_mutex.unlock();
parse_thread_buffer_map_mutex.unlock();
parse_done();
}
parsing.unlock();
parsing_done();
INFO("Parsing completed");
}
});
parse.detach();
});
}
}
@ -353,7 +314,9 @@ Glib::RefPtr<Gsv::Buffer> Source::Controller::buffer() {
return view.get_source_buffer();
}
bool Source::Controller::OnKeyPress(GdkEventKey* key) {
//TODO: move indentation to Parser, replace indentation methods with a better implementation or
//maybe use libclang
bool Source::Controller::on_key_press(GdkEventKey* key) {
const std::regex bracket_regex("^( *).*\\{ *$");
const std::regex no_bracket_statement_regex("^( *)(if|for|else if|catch|while) *\\(.*[^;}] *$");
const std::regex no_bracket_no_para_statement_regex("^( *)(else|try|do) *$");
@ -361,7 +324,7 @@ bool Source::Controller::OnKeyPress(GdkEventKey* key) {
//Indent as in previous line, and indent right after if/else/etc
if(key->keyval==GDK_KEY_Return && key->state==0) {
string line(view.GetLineBeforeInsert());
string line(view.get_line_before_insert());
std::smatch sm;
if(std::regex_match(line, sm, bracket_regex)) {
buffer()->insert_at_cursor("\n"+sm[1].str()+config.tab+"\n"+sm[1].str()+"}");
@ -383,7 +346,7 @@ bool Source::Controller::OnKeyPress(GdkEventKey* key) {
std::smatch sm2;
size_t line_nr=buffer()->get_insert()->get_iter().get_line();
if(line_nr>0 && sm[1].str().size()>=config.tab_size) {
string previous_line=view.GetLine(line_nr-1);
string previous_line=view.get_line(line_nr-1);
if(!std::regex_match(previous_line, sm2, bracket_regex)) {
if(std::regex_match(previous_line, sm2, no_bracket_statement_regex)) {
buffer()->insert_at_cursor("\n"+sm2[1].str());
@ -422,7 +385,7 @@ bool Source::Controller::OnKeyPress(GdkEventKey* key) {
int line_end=selection_end.get_line();
for(int line_nr=line_start;line_nr<=line_end;line_nr++) {
string line=view.GetLine(line_nr);
string line=view.get_line(line_nr);
if(!(line.size()>=config.tab_size && line.substr(0, config.tab_size)==config.tab))
return true;
}
@ -439,7 +402,7 @@ bool Source::Controller::OnKeyPress(GdkEventKey* key) {
}
//Indent left when writing } on a new line
else if(key->keyval==GDK_KEY_braceright) {
string line=view.GetLineBeforeInsert();
string line=view.get_line_before_insert();
if(line.size()>=config.tab_size) {
for(auto c: line) {
if(c!=' ')
@ -460,8 +423,8 @@ bool Source::Controller::OnKeyPress(GdkEventKey* key) {
Gtk::TextIter insert_it=buffer()->get_insert()->get_iter();
int line_nr=insert_it.get_line();
if(line_nr>0) {
string line=view.GetLine(line_nr);
string previous_line=view.GetLine(line_nr-1);
string line=view.get_line(line_nr);
string previous_line=view.get_line(line_nr-1);
smatch sm;
if(std::regex_match(previous_line, sm, spaces_regex)) {
if(line==sm[1]) {

126
juci/source.h
Unescape View File

@ -8,6 +8,7 @@
#include <thread>
#include <mutex>
#include <string>
#include <atomic>
#include "gtksourceviewmm.h"
namespace Notebook {
@ -17,139 +18,118 @@ namespace Notebook {
namespace Source {
class Config {
public:
const std::unordered_map<std::string, std::string>& tagtable() const;
const std::unordered_map<std::string, std::string>& typetable() const;
std::vector<std::string>& extensiontable();
void SetTagTable(const std::unordered_map<std::string, std::string>
&tagtable);
void InsertTag(const std::string &key, const std::string &value);
void SetTypeTable(const std::unordered_map<std::string, std::string>
&tagtable);
void InsertType(const std::string &key, const std::string &value);
void InsertExtension(const std::string &ext);
std::vector<std::string> extensiontable_;
// TODO: Have to clean away all the simple setter and getter methods at some point. It creates too much unnecessary code
bool legal_extension(std::string e) const ;
unsigned tab_size;
bool show_line_numbers, highlight_current_line;
std::string tab, background, font;
private:
std::unordered_map<std::string, std::string> tagtable_, typetable_;
std::vector<std::string> extensions;
std::unordered_map<std::string, std::string> tags, types;
}; // class Config
class Location {
public:
Location(const Location &location);
Location(int line_number, int column_offset);
int line_number() const { return line_number_; }
int column_offset() const { return column_offset_; }
private:
int line_number_;
int column_offset_;
Location(int line_number, int column_offset):
line_number(line_number), column_offset(column_offset) {}
int line_number;
int column_offset;
};
class Range {
public:
Range(const Location &start, const Location &end, int kind);
Range(const Range &org);
const Location& start() const { return start_; }
const Location& end() const { return end_; }
int kind() const { return kind_; }
private:
Location start_;
Location end_;
int kind_;
Range(const Location &start, const Location &end, int kind):
start(start), end(end), kind(kind) {}
Location start;
Location end;
int kind;
};
class View : public Gsv::View {
public:
View();
virtual ~View() { }
void OnLineEdit(const std::vector<Range> &locations,
const Config &config);
void OnUpdateSyntax(const std::vector<Range> &locations,
const Config &config);
std::string GetLine(size_t line_number);
std::string GetLineBeforeInsert();
std::string get_line(size_t line_number);
std::string get_line_before_insert();
}; // class View
class AutoCompleteChunk {
public:
explicit AutoCompleteChunk(const clang::CompletionChunk &chunk) :
chunk_(chunk.chunk()), kind_(chunk.kind()) { }
const std::string& chunk() const { return chunk_; }
const clang::CompletionChunkKind& kind() const { return kind_; }
private:
std::string chunk_;
enum clang::CompletionChunkKind kind_;
explicit AutoCompleteChunk(const clang::CompletionChunk &clang_chunk) :
chunk(clang_chunk.chunk()), kind(clang_chunk.kind()) { }
std::string chunk;
enum clang::CompletionChunkKind kind;
};
class AutoCompleteData {
public:
explicit AutoCompleteData(const std::vector<AutoCompleteChunk> &chunks) :
chunks_(chunks) { }
std::vector<AutoCompleteChunk> chunks_;
chunks(chunks) { }
std::vector<AutoCompleteChunk> chunks;
};
class Controller;
class Parser{
public:
Parser(const std::vector<std::unique_ptr<Source::Controller> > &controllers):
controllers(controllers) {}
~Parser();
// inits the syntax highligthing on file open
void InitSyntaxHighlighting(const std::string &filepath,
void init_syntax_highlighting(const std::string &filepath,
const std::string &project_path,
const std::map<std::string, std::string>
&buffers,
int start_offset,
int end_offset,
clang::Index *index);
void GetAutoCompleteSuggestions(const std::map<std::string, std::string>
&buffers,
int line_number,
int column,
std::vector<AutoCompleteData>
*suggestions);
int ReParse(const std::map<std::string, std::string> &buffers);
std::vector<Range> ExtractTokens(int, int);
std::vector<Source::AutoCompleteData> get_autocomplete_suggestions(int line_number, int column);
int reparse(const std::map<std::string, std::string> &buffers);
std::vector<Range> extract_tokens(int, int);
std::string file_path;
std::string project_path;
static clang::Index clang_index;
std::map<std::string, std::string> get_buffer_map() const;
std::mutex parsing_mutex;
private:
std::unique_ptr<clang::TranslationUnit> tu_; //use unique_ptr since it is not initialized in constructor
void HighlightToken(clang::Token *token,
void highlight_token(clang::Token *token,
std::vector<Range> *source_ranges,
int token_kind);
void HighlightCursor(clang::Token *token,
void highlight_cursor(clang::Token *token,
std::vector<Range> *source_ranges);
std::vector<std::string> get_compilation_commands();
//controllers is needed here, no way around that I think
const std::vector<std::unique_ptr<Source::Controller> > &controllers;
};
class Controller {
public:
Controller(const Source::Config &config,
Notebook::Controller &notebook);
Controller();
const std::vector<std::unique_ptr<Source::Controller> > &controllers);
~Controller();
void OnNewEmptyFile();
void OnOpenFile(const std::string &filename);
void GetAutoCompleteSuggestions(int line_number,
int column,
std::vector<AutoCompleteData>
*suggestions);
void update_syntax(const std::vector<Range> &locations);
void on_new_empty_file();
void on_open_file(const std::string &filename);
Glib::RefPtr<Gsv::Buffer> buffer();
bool OnKeyPress(GdkEventKey* key);
bool on_key_press(GdkEventKey* key);
bool is_saved = false; //TODO: Is never set to false in Notebook::Controller
bool is_changed = false; //TODO: Is never set to true
bool is_saved = true;
Parser parser;
View view;
std::function<void(bool was_saved)> signal_buffer_changed;
private:
void OnLineEdit();
void OnSaveFile();
std::mutex parsing;
Glib::Dispatcher parsing_done;
Glib::Dispatcher parse_done;
Glib::Dispatcher parse_start;
std::thread parse_thread;
std::map<std::string, std::string> parse_thread_buffer_map;
std::mutex parse_thread_buffer_map_mutex;
std::atomic<bool> parse_thread_go;
std::atomic<bool> parse_thread_mapped;
std::atomic<bool> parse_thread_stop;
const Config& config;
Notebook::Controller& notebook; //TODO: should maybe be const, but that involves a small change in libclangmm
}; // class Controller
} // namespace Source
#endif // JUCI_SOURCE_H_

Write Preview
Loading…
Cancel
Save