void TestClassDlg::DoRefreshFunctions(bool repportError)
{
std::vector<TagEntryPtr> matches;
// search m_tags for suitable name
for(size_t i = 0; i < m_tags.size(); i++) {
TagEntryPtr tag = m_tags.at(i);
if(tag->GetName() == m_textCtrlClassName->GetValue()) {
matches.push_back(tag);
}
}
if(matches.empty()) {
if(repportError) {
wxMessageBox(_("Could not find match for class '") + m_textCtrlClassName->GetValue() + wxT("'"),
_("CodeLite"),
wxICON_WARNING | wxOK);
}
return;
}
wxString theClass;
if(matches.size() == 1) {
// single match we are good
theClass = matches.at(0)->GetPath();
} else {
// suggest the user a multiple choice
wxArrayString choices;
for(size_t i = 0; i < matches.size(); i++) {
wxString option;
TagEntryPtr t = matches.at(i);
choices.Add(t->GetPath());
}
theClass = wxGetSingleChoice(_("Select class:"), _("Select class:"), choices, this);
}
if(theClass.empty()) { // user clicked 'Cancel'
return;
}
// get list of methods for the given path
matches.clear();
m_manager->GetTagsManager()->TagsByScope(theClass, wxT("prototype"), matches, false, true);
// populate the list control
wxArrayString methods;
for(size_t i = 0; i < matches.size(); i++) {
TagEntryPtr t = matches.at(i);
methods.Add(t->GetName() + t->GetSignature());
}
m_checkListMethods->Clear();
m_checkListMethods->Append(methods);
// check all items
for(unsigned int idx = 0; idx < m_checkListMethods->GetCount(); idx++) {
m_checkListMethods->Check(idx, true);
}
}
int OpenTypeVListCtrl::FindMatch(const wxString& word)
{
// first try to match case sensetive
int possible_match(wxNOT_FOUND);
// full match
for(size_t i=0; i<m_tags.size(); i++) {
TagEntryPtr t = m_tags.at(i);
wxString s1(word);
wxString s2(t->GetName());
// first try full match
if(s2.StartsWith(s1)) {
if(possible_match == wxNOT_FOUND){
possible_match = (int)i;
}
if(s2 == s1) {
return (int)i;
}
} else {
if(possible_match != wxNOT_FOUND){
// since the tags are sorted, we will not find any matches beyond this point
return possible_match;
}
}
}
// if we reached this part, possible_match is wxNOT_FOUND
for(size_t i=0; i<m_tags.size(); i++) {
TagEntryPtr t = m_tags.at(i);
wxString s1(word);
wxString s2(t->GetName());
s1.MakeLower(); s2.MakeLower();
// first try full match
if(s2.StartsWith(s1)) {
if(possible_match == wxNOT_FOUND){
possible_match = (int)i;
}
if(s2 == s1) {
return (int)i;
}
} else {
if(possible_match != wxNOT_FOUND){
// we will not find any matches beyond this point
return possible_match;
}
}
}
return wxNOT_FOUND;
}
wxString OpenTypeVListCtrl::OnGetItemText(long item, long column) const
{
if(item >= (long)m_tags.size()) {
return wxEmptyString;
}
TagEntryPtr t = m_tags.at(item);
switch(column) {
case 0: // name
return t->GetName();
case 1: // scope
return t->GetScope();
case 2: // file
return t->GetFile();
case 3: // line
{
wxString l;
l << t->GetLine();
return l;
}
default:
return wxEmptyString;
}
return wxEmptyString;
}
bool CodeCompletionManager::DoCtagsGotoDecl(LEditor* editor)
{
TagEntryPtr tag = editor->GetContext()->GetTagAtCaret(true, false);
if (tag) {
LEditor *editor = clMainFrame::Get()->GetMainBook()->OpenFile(tag->GetFile(), wxEmptyString, tag->GetLine()-1);
if(!editor) {
return false;
}
editor->FindAndSelect(tag->GetPattern(), tag->GetName());
return true;
}
return false;
}
bool CodeCompletionManager::DoCtagsGotoDecl(LEditor* editor)
{
TagEntryPtr tag = editor->GetContext()->GetTagAtCaret(true, false);
if (tag) {
LEditor *editor = clMainFrame::Get()->GetMainBook()->OpenFile(tag->GetFile(), wxEmptyString, tag->GetLine()-1);
if(!editor) {
return false;
}
// Use the async funtion here. Synchronously usually works but, if the file wasn't loaded, sometimes the EnsureVisible code is called too early and fails
editor->FindAndSelectV(tag->GetPattern(), tag->GetName());
return true;
}
return false;
}
wxString ImplementParentVirtualFunctionsDialog::DoMakeCommentForTag(TagEntryPtr tag) const
{
// Add doxygen comment
CppCommentCreator commentCreator(tag, m_doxyPrefix);
DoxygenComment dc;
dc.comment = commentCreator.CreateComment();
dc.name = tag->GetName();
m_contextCpp->DoMakeDoxyCommentString( dc );
// Format the comment
wxString textComment = dc.comment;
textComment.Replace("\r", "\n");
wxArrayString lines = wxStringTokenize(textComment, "\n", wxTOKEN_STRTOK);
textComment.Clear();
for (size_t i=0; i<lines.GetCount(); ++i)
textComment << lines.Item(i) << wxT("\n");
return textComment;
}
void OpenResourceDialog::DoPopulateTags()
{
bool gotExactMatch(false);
// Next, add the tags
TagEntryPtrVector_t tags;
if(m_userFilters.IsEmpty()) return;
m_manager->GetTagsManager()->GetTagsByPartialNames(m_userFilters, tags);
for(size_t i = 0; i < tags.size(); i++) {
TagEntryPtr tag = tags.at(i);
// Filter out non relevanting entries
if(!m_filters.IsEmpty() && m_filters.Index(tag->GetKind()) == wxNOT_FOUND) continue;
if(!MatchesFilter(tag->GetFullDisplayName())) { continue; }
wxString name(tag->GetName());
// keep the fullpath
wxDataViewItem item;
wxString fullname;
if(tag->IsMethod()) {
fullname = wxString::Format(wxT("%s::%s%s"), tag->GetScope().c_str(), tag->GetName().c_str(),
tag->GetSignature().c_str());
item = DoAppendLine(tag->GetName(), fullname, (tag->GetKind() == wxT("function")),
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(),
tag->GetName(), tag->GetScope()),
DoGetTagImg(tag));
} else {
fullname = wxString::Format(wxT("%s::%s"), tag->GetScope().c_str(), tag->GetName().c_str());
item = DoAppendLine(tag->GetName(), fullname, false,
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(),
tag->GetName(), tag->GetScope()),
DoGetTagImg(tag));
}
if((m_userFilters.GetCount() == 1) && (m_userFilters.Item(0).CmpNoCase(name) == 0) && !gotExactMatch) {
gotExactMatch = true;
DoSelectItem(item);
}
}
}
void SmartCompletion::OnCodeCompletionSelectionMade(clCodeCompletionEvent& event)
{
event.Skip();
if(!m_config.IsEnabled()) return;
CHECK_PTR_RET(event.GetEntry());
// Collect info about this match
TagEntryPtr tag = event.GetEntry()->GetTag();
if(tag) {
WeightTable_t& T = *m_pCCWeight;
// we have an associated tag
wxString k = tag->GetScope() + "::" + tag->GetName();
if(T.count(k) == 0) {
T[k] = 1;
} else {
T[k]++;
}
m_config.GetUsageDb().StoreCCUsage(k, T[k]);
}
}
bool operator()(const TagEntryPtr& rStart, const TagEntryPtr& rEnd)
{
return rEnd->GetName().Cmp(rStart->GetName()) > 0;
}
void OpenResourceDialog::DoPopulateTags()
{
if (m_tags.empty())
return;
bool gotExactMatch(false);
wxArrayString tmpArr;
wxString curSel = m_textCtrlResourceName->GetValue();
wxString curSelNoStar;
if (!curSel.Trim().Trim(false).IsEmpty()) {
curSel = curSel.MakeLower().Trim().Trim(false);
curSelNoStar = curSel.c_str();
for (size_t i=0; i<m_tags.size(); i++) {
TagEntryPtr tag = m_tags.at(i);
wxString name(tag->GetName());
name.MakeLower();
//append wildcard at the end
if (!curSel.EndsWith(wxT("*"))) {
curSel << wxT("*");
}
// FR# [2008133]
if (m_checkBoxUsePartialMatching->IsChecked() && !curSel.StartsWith(wxT("*"))) {
curSel.Prepend(wxT("*"));
}
if (wxMatchWild(curSel, name)) {
// keep the fullpath
int index(0);
if(tag->GetKind() == wxT("function") || tag->GetKind() == wxT("prototype"))
index = DoAppendLine(tag->GetName(),
tag->GetSignature(),
tag->GetScope(),
tag->GetKind() == wxT("function"),
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(), m_type, tag->GetName(), tag->GetScope()));
else
index = DoAppendLine(tag->GetName(),
tag->GetScope(),
wxT(""),
false,
new OpenResourceDialogItemData(tag->GetFile(), tag->GetLine(), tag->GetPattern(), m_type, tag->GetName(), tag->GetScope()));
if (curSelNoStar == name && !gotExactMatch) {
gotExactMatch = true;
DoSelectItem(index);
}
}
}
}
if (m_listOptions->GetItemCount() == 150) {
m_staticTextErrorMessage->SetLabel(wxT("Too many matches, please narrow down your search"));
}
if (!gotExactMatch && m_listOptions->GetItemCount()) {
DoSelectItem(0);
}
}
bool RefactoringEngine::DoResolveWord(TextStatesPtr states, const wxFileName& fn, int pos, int line, const wxString &word, RefactorSource *rs)
{
std::vector<TagEntryPtr> tags;
// try to process the current expression
wxString expr = GetExpression(pos, states);
// sanity
if(states->text.length() < (size_t)pos + 1)
return false;
// get the scope
// Optimize the text for large files
wxString text(states->text.substr(0, pos + 1));
// we simply collect declarations & implementations
//try implemetation first
bool found(false);
TagsManagerST::Get()->FindImplDecl(fn, line, expr, word, text, tags, true, true);
if (tags.empty() == false) {
// try to see if we got a function and not class/struct
for (size_t i=0; i<tags.size(); i++) {
TagEntryPtr tag = tags.at(i);
// find first non class/struct tag
if (tag->GetKind() != wxT("class") && tag->GetKind() != wxT("struct")) {
// if there is no match, add it anyways
if (!found) {
rs->isClass = (tag->GetKind() == wxT("class") ||tag->GetKind() == wxT("struct"));
rs->name = tag->GetName();
rs->scope = tag->GetScope();
found = true;
} else if (rs->scope == wxT("<global>") && rs->isClass == false) {
// give predecense to <global> variables
rs->isClass = (tag->GetKind() == wxT("class") ||tag->GetKind() == wxT("struct"));
rs->name = tag->GetName();
rs->scope = tag->GetScope();
found = true;
}
found = true;
}
}
// if no match was found, keep the first result but keep searching
if ( !found ) {
TagEntryPtr tag = tags.at(0);
rs->scope = tag->GetScope();
rs->name = tag->GetName();
rs->isClass = tag->IsClass() || tag->IsStruct();
found = true;
} else {
return true;
}
}
// Ok, the "implementation" search did not yield definite results, try declaration
tags.clear();
TagsManagerST::Get()->FindImplDecl(fn, line, expr, word, text, tags, false, true);
if (tags.empty() == false) {
// try to see if we got a function and not class/struct
for (size_t i=0; i<tags.size(); i++) {
TagEntryPtr tag = tags.at(i);
// find first non class/struct tag
if (tag->GetKind() != wxT("class") && tag->GetKind() != wxT("struct")) {
rs->name = tag->GetName();
rs->scope = tag->GetScope();
return true;
}
}
// if no match was found, keep the first result but keep searching
if ( !found ) {
TagEntryPtr tag = tags.at(0);
rs->scope = tag->GetScope();
rs->name = tag->GetName();
rs->isClass = tag->IsClass() || tag->IsStruct();
}
return true;
}
// if we got so far, CC failed to parse the expression
return false;
}
void clCallTip::Initialize(const std::vector<TagEntryPtr> &tips)
{
std::map<wxString, tagCallTipInfo> mymap;
for (size_t i=0; i< tips.size(); i++) {
tagCallTipInfo cti;
TagEntryPtr t = tips.at(i);
if ( t->IsMethod() ) {
wxString raw_sig ( t->GetSignature().Trim().Trim(false) );
// evaluate the return value of the tag
cti.retValue = TagsManagerST::Get()->GetFunctionReturnValueFromPattern(t);
bool hasDefaultValues = (raw_sig.Find(wxT("=")) != wxNOT_FOUND);
// the key for unique entries is the function prototype without the variables names and
// any default values
wxString key = TagsManagerST::Get()->NormalizeFunctionSig(raw_sig, Normalize_Func_Reverse_Macro);
// the signature that we want to keep is one with name & default values, so try and get the maximum out of the
// function signature
wxString full_signature = TagsManagerST::Get()->NormalizeFunctionSig(raw_sig, Normalize_Func_Name | Normalize_Func_Default_value | Normalize_Func_Reverse_Macro, &cti.paramLen);
cti.sig = full_signature;
if (hasDefaultValues) {
// incase default values exist in this prototype,
// update/insert this signature
mymap[key] = cti;
}
// make sure we dont add duplicates
if ( mymap.find(key) == mymap.end() ) {
// add it
mymap[key] = cti;
}
} else {
// macro
wxString macroName = t->GetName();
wxString pattern = t->GetPattern();
int where = pattern.Find(macroName);
if (where != wxNOT_FOUND) {
//remove the #define <name> from the pattern
pattern = pattern.Mid(where + macroName.Length());
pattern = pattern.Trim().Trim(false);
if (pattern.StartsWith(wxT("("))) {
//this macro has the form of a function
pattern = pattern.BeforeFirst(wxT(')'));
pattern.Append(wxT(')'));
cti.sig = pattern.Trim().Trim(false);
mymap[cti.sig] = cti;
}
}
}
}
std::map<wxString, tagCallTipInfo>::iterator iter = mymap.begin();
m_tips.clear();
for (; iter != mymap.end(); iter++) {
wxString tip;
if ( iter->second.retValue.empty() == false ) {
tip << iter->second.retValue.Trim(false).Trim() << wxT(" : ");
}
tip << iter->second.sig;
clTipInfo ti;
ti.paramLen = iter->second.paramLen;
ti.str = tip;
m_tips.push_back(ti);
}
}
