wxCodeCompletionBoxEntry::Vec_t wxCodeCompletionBox::TagsToEntries(const TagEntryPtrVector_t& tags)
{
wxCodeCompletionBoxEntry::Vec_t entries;
for(size_t i = 0; i < tags.size(); ++i) {
TagEntryPtr tag = tags.at(i);
wxString text = tag->GetDisplayName().Trim().Trim(false);
int imgIndex = GetImageId(tag);
wxCodeCompletionBoxEntry::Ptr_t entry = wxCodeCompletionBoxEntry::New(text, imgIndex);
entry->m_tag = tag;
entries.push_back(entry);
}
return entries;
}
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;
}
void RefactoringEngine::RenameLocalSymbol(const wxString& symname, const wxFileName& fn, int line, int pos)
{
// Clear previous results
Clear();
// Load the file and get a state map + the text from the scanner
CppWordScanner scanner(fn.GetFullPath());
// get the current file states
TextStatesPtr states = scanner.states();
if( !states ) {
return;
}
// get the local by scanning from the current function's
TagEntryPtr tag = TagsManagerST::Get()->FunctionFromFileLine(fn, line + 1);
if( !tag ) {
return;
}
// Get the line number of the function
int funcLine = tag->GetLine() - 1;
// Convert the line number to offset
int from = states->LineToPos (funcLine);
int to = states->FunctionEndPos(from);
if(to == wxNOT_FOUND)
return;
// search for matches in the given range
CppTokensMap l;
scanner.Match(symname, l, from, to);
CppToken::List_t tokens;
l.findTokens(symname, tokens);
if (tokens.empty())
return;
// Loop over the matches
// Incase we did manage to resolve the word, it means that it is NOT a local variable (DoResolveWord only wors for globals NOT for locals)
RefactorSource target;
std::list<CppToken>::iterator iter = tokens.begin();
for (; iter != tokens.end(); iter++) {
wxFileName f( iter->getFilename() );
if (!DoResolveWord(states, wxFileName(iter->getFilename()), iter->getOffset(), line, symname, &target)) {
m_candidates.push_back( *iter );
}
}
}
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;
}
wxCodeCompletionBoxEntry::Ptr_t wxCodeCompletionBox::TagToEntry(TagEntryPtr tag)
{
wxString text = tag->GetDisplayName().Trim().Trim(false);
int imgIndex = GetImageId(tag);
wxCodeCompletionBoxEntry::Ptr_t entry = wxCodeCompletionBoxEntry::New(text, imgIndex);
return entry;
}
void FindResultsTab::OnSearchMatch(wxCommandEvent& e)
{
SearchResultList* res = (SearchResultList*)e.GetClientData();
if(!res) return;
SearchResultList::iterator iter = res->begin();
for(; iter != res->end(); ++iter) {
if(m_matchInfo.empty() || m_matchInfo.rbegin()->second.GetFileName() != iter->GetFileName()) {
if(!m_matchInfo.empty()) {
AppendText("\n");
}
wxFileName fn(iter->GetFileName());
fn.MakeRelativeTo();
AppendText(fn.GetFullPath() + wxT("\n"));
}
int lineno = m_sci->GetLineCount() - 1;
m_matchInfo.insert(std::make_pair(lineno, *iter));
wxString text = iter->GetPattern();
// int delta = -text.Length();
// text.Trim(false);
// delta += text.Length();
// text.Trim();
wxString linenum = wxString::Format(wxT(" %5u: "), iter->GetLineNumber());
SearchData* d = GetSearchData();
// Print the scope name
if(d->GetDisplayScope()) {
TagEntryPtr tag = TagsManagerST::Get()->FunctionFromFileLine(iter->GetFileName(), iter->GetLineNumber());
wxString scopeName(wxT("global"));
if(tag) {
scopeName = tag->GetPath();
}
linenum << wxT("[ ") << scopeName << wxT(" ] ");
iter->SetScope(scopeName);
}
AppendText(linenum + text + wxT("\n"));
int indicatorStartPos = m_sci->PositionFromLine(lineno) + iter->GetColumn() + linenum.Length();
int indicatorLen = iter->GetLen();
m_indicators.push_back(indicatorStartPos);
m_sci->IndicatorFillRange(indicatorStartPos, indicatorLen);
}
wxDELETE(res);
}
wxString WizardsPlugin::DoGetVirtualFuncImpl(const NewClassInfo &info)
{
if (info.implAllVirtual == false && info.implAllPureVirtual == false)
return wxEmptyString;
//get list of all parent virtual functions
std::vector< TagEntryPtr > tmp_tags;
std::vector< TagEntryPtr > no_dup_tags;
std::vector< TagEntryPtr > tags;
for (std::vector< TagEntryPtr >::size_type i=0; i< info.parents.size(); i++) {
ClassParentInfo pi = info.parents.at(i);
// Load all prototypes / functions of the parent scope
m_mgr->GetTagsManager()->TagsByScope(pi.name, wxT("prototype"), tmp_tags, false);
m_mgr->GetTagsManager()->TagsByScope(pi.name, wxT("function"), tmp_tags, false);
}
// and finally sort the results
std::sort(tmp_tags.begin(), tmp_tags.end(), ascendingSortOp());
GizmosRemoveDuplicates(tmp_tags, no_dup_tags);
//filter out all non virtual functions
for (std::vector< TagEntryPtr >::size_type i=0; i< no_dup_tags.size(); i++) {
TagEntryPtr tt = no_dup_tags.at(i);
bool collect(false);
if (info.implAllVirtual) {
collect = m_mgr->GetTagsManager()->IsVirtual(tt);
} else if (info.implAllPureVirtual) {
collect = m_mgr->GetTagsManager()->IsPureVirtual(tt);
}
if (collect) {
tags.push_back(tt);
}
}
wxString impl;
for (std::vector< TagEntryPtr >::size_type i=0; i< tags.size(); i++) {
TagEntryPtr tt = tags.at(i);
// we are not interested in Ctor-Dtor
if ( tt->IsConstructor() || tt->IsDestructor() )
continue;
impl << m_mgr->GetTagsManager()->FormatFunction(tt, FunctionFormat_Impl, info.name);
}
return impl;
}
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);
}
}
void SymbolsDialog::AddSymbol(const TagEntryPtr &tag, bool sel)
{
//-------------------------------------------------------
// Populate the columns
//-------------------------------------------------------
wxString line;
line << tag->GetLine();
long index = AppendListCtrlRow(m_results);
SetColumnText(m_results, index, 0, tag->GetFullDisplayName());
SetColumnText(m_results, index, 1, tag->GetKind());
SetColumnText(m_results, index, 2, tag->GetFile());
SetColumnText(m_results, index, 3, line);
SetColumnText(m_results, index, 4, tag->GetPattern());
// list ctrl can reorder items, so use returned index to insert tag
m_tags.insert(m_tags.begin()+index, tag);
}
void PHPCodeCompletion::OnFindSymbol(clCodeCompletionEvent& e)
{
e.Skip();
if(PHPWorkspace::Get()->IsOpen()) {
if(!CanCodeComplete(e)) return;
e.Skip(false);
IEditor* editor = dynamic_cast<IEditor*>(e.GetEditor());
if(editor) {
wxString word = editor->GetWordAtCaret();
if(word.IsEmpty()) return;
PHPEntityBase::List_t symbols = m_lookupTable.FindSymbol(word);
if(symbols.size() == 1) {
PHPEntityBase::Ptr_t match = *symbols.begin();
DoOpenEditorForEntry(match);
} else {
// Convert the matches to clSelectSymbolDialogEntry::List_t
clSelectSymbolDialogEntry::List_t entries;
std::for_each(symbols.begin(), symbols.end(), [&](PHPEntityBase::Ptr_t entry) {
TagEntryPtr tag = DoPHPEntityToTagEntry(entry);
wxBitmap bmp = wxCodeCompletionBox::GetBitmap(tag);
clSelectSymbolDialogEntry m;
m.bmp = bmp;
m.name = entry->GetFullName();
m.clientData = new PHPFindSymbol_ClientData(entry);
m.help = tag->GetKind();
entries.push_back(m);
});
// Show selection dialog
clSelectSymbolDialog dlg(EventNotifier::Get()->TopFrame(), entries);
if(dlg.ShowModal() != wxID_OK) return;
PHPFindSymbol_ClientData* cd = dynamic_cast<PHPFindSymbol_ClientData*>(dlg.GetSelection());
if(cd) {
DoOpenEditorForEntry(cd->m_ptr);
}
}
}
}
}
void NavBar::UpdateScope(TagEntryPtr tag)
{
size_t sel = m_func->GetSelection();
if(tag && sel < m_tags.size() && *m_tags[sel] == *tag) return;
wxWindowUpdateLocker locker(this);
m_tags.clear();
m_scope->Clear();
m_func->Clear();
if(tag) {
m_tags.push_back(tag);
m_scope->AppendString(tag->GetScope());
m_func->AppendString(tag->GetDisplayName());
m_scope->SetSelection(0);
m_func->SetSelection(0);
DoPopulateTags(DoGetCurFileName());
}
}
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]);
}
}
wxBitmap OpenResourceDialog::DoGetTagImg(TagEntryPtr tag)
{
wxString kind = tag->GetKind();
wxString access = tag->GetAccess();
wxBitmap bmp = m_tagImgMap[wxT("text")];
if(kind == wxT("class")) bmp = m_tagImgMap[wxT("class")];
if(kind == wxT("struct")) bmp = m_tagImgMap[wxT("struct")];
if(kind == wxT("namespace")) bmp = m_tagImgMap[wxT("namespace")];
if(kind == wxT("variable")) bmp = m_tagImgMap[wxT("member_public")];
if(kind == wxT("typedef")) bmp = m_tagImgMap[wxT("typedef")];
if(kind == wxT("member") && access.Contains(wxT("private"))) bmp = m_tagImgMap[wxT("member_private")];
if(kind == wxT("member") && access.Contains(wxT("public"))) bmp = m_tagImgMap[wxT("member_public")];
if(kind == wxT("member") && access.Contains(wxT("protected"))) bmp = m_tagImgMap[wxT("member_protected")];
if(kind == wxT("member")) bmp = m_tagImgMap[wxT("member_public")];
if((kind == wxT("function") || kind == wxT("prototype")) && access.Contains(wxT("private")))
bmp = m_tagImgMap[wxT("function_private")];
if((kind == wxT("function") || kind == wxT("prototype")) && (access.Contains(wxT("public")) || access.IsEmpty()))
bmp = m_tagImgMap[wxT("function_public")];
if((kind == wxT("function") || kind == wxT("prototype")) && access.Contains(wxT("protected")))
bmp = m_tagImgMap[wxT("function_protected")];
if(kind == wxT("macro")) bmp = m_tagImgMap[wxT("typedef")];
if(kind == wxT("enum")) bmp = m_tagImgMap[wxT("enum")];
if(kind == wxT("enumerator")) bmp = m_tagImgMap[wxT("enumerator")];
return bmp;
}
int wxCodeCompletionBox::GetImageId(TagEntryPtr entry)
{
wxString kind = entry->GetKind();
wxString access = entry->GetAccess();
if(kind == wxT("class")) return 0;
if(kind == wxT("struct")) return 1;
if(kind == wxT("namespace")) return 2;
if(kind == wxT("variable")) return 3;
if(kind == wxT("typedef")) return 4;
if(kind == wxT("member") && access.Contains(wxT("private"))) return 5;
if(kind == wxT("member") && access.Contains(wxT("public"))) return 6;
if(kind == wxT("member") && access.Contains(wxT("protected"))) return 7;
// member with no access? (maybe part of namespace??)
if(kind == wxT("member")) return 6;
if((kind == wxT("function") || kind == wxT("prototype")) && access.Contains(wxT("private"))) return 8;
if((kind == wxT("function") || kind == wxT("prototype")) && (access.Contains(wxT("public")) || access.IsEmpty()))
return 9;
if((kind == wxT("function") || kind == wxT("prototype")) && access.Contains(wxT("protected"))) return 10;
if(kind == wxT("macro")) return 11;
if(kind == wxT("enum")) return 12;
if(kind == wxT("enumerator")) return 13;
if(kind == wxT("cpp_keyword")) return 17;
return wxNOT_FOUND;
}
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;
}
TagEntryPtr RefactoringEngine::SyncSignature(const wxFileName& fn,
int line,
int pos,
const wxString &word,
const wxString &text,
const wxString &expr)
{
TagEntryPtr func = TagsManagerST::Get()->FunctionFromFileLine(fn, line);
if(!func)
return NULL;
bool bIsImpl = (func->GetKind() == wxT("function"));
// Found the counterpart
std::vector<TagEntryPtr> tags;
TagsManagerST::Get()->FindImplDecl(fn, line, expr, word, text, tags, !bIsImpl);
if(tags.size() != 1)
return NULL;
TagEntryPtr tag = tags.at(0);
if(tag->IsMethod() == false)
return NULL;
wxString signature;
if (bIsImpl) {
// The "source" is an implementaion, which means that we need to prepare declaration signature
// this could be tricky since we might lose the "default" values
signature = TagsManagerST::Get()->NormalizeFunctionSig(func->GetSignature(), Normalize_Func_Default_value|Normalize_Func_Name|Normalize_Func_Reverse_Macro);
} else {
// Prepare an "implementation" signature
signature = TagsManagerST::Get()->NormalizeFunctionSig(func->GetSignature(), Normalize_Func_Name|Normalize_Func_Reverse_Macro);
}
tag->SetSignature(signature);
return tag;
}
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);
}
}
void OpenResourceDialog::DoPopulateTags()
{
bool gotExactMatch(false);
// Next, add the tags
TagEntryPtrVector_t tags;
if(m_userFilters.IsEmpty()) return;
m_manager->GetTagsManager()->GetTagsByPartialName(m_userFilters.Item(0), 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->GetName())) continue;
wxString name(tag->GetName());
// keep the fullpath
wxDataViewItem item;
wxString fullname;
if(tag->GetKind() == wxT("function") || tag->GetKind() == wxT("prototype")) {
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);
}
}
}
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);
}
}
CxxTemplateFunction::CxxTemplateFunction(TagEntryPtr tag)
{
m_scanner = ::LexerNew(tag->GetPatternClean(), kLexerOpt_None);
m_sigScanner = ::LexerNew(tag->GetSignature(), kLexerOpt_None);
}
void FindUsageTab::ShowUsage(const std::list<CppToken>& matches, const wxString& searchWhat)
{
Clear();
int lineNumber(0);
wxString text;
wxString curfile;
wxString curfileContent;
wxArrayString lines;
text = wxString::Format(_("===== Finding references of '%s' =====\n"), searchWhat.c_str());
lineNumber++;
std::list<CppToken>::const_iterator iter = matches.begin();
for(; iter != matches.end(); iter++) {
// Print the line number
wxString file_name(iter->getFilename());
if(curfile != file_name) {
curfile = file_name;
wxFileName fn(file_name);
fn.MakeRelativeTo();
text << fn.GetFullPath() << wxT("\n");
lineNumber++;
// Load the file content
wxLogNull nolog;
wxFFile thefile(file_name, wxT("rb"));
if(thefile.IsOpened()) {
wxFileOffset size = thefile.Length();
wxString fileData;
fileData.Alloc(size);
curfileContent.Clear();
wxCSConv fontEncConv(wxFONTENCODING_ISO8859_1);
thefile.ReadAll(&curfileContent, fontEncConv);
// break the current file into lines, a line can be an empty string
lines = wxStringTokenize(curfileContent, wxT("\n"), wxTOKEN_RET_EMPTY_ALL);
}
}
// Keep the match
m_matches[lineNumber] = *iter;
// Format the message
wxString linenum = wxString::Format(wxT(" %5u "), (unsigned int)iter->getLineNumber() + 1);
wxString scopeName(wxT("<global>"));
TagEntryPtr tag = TagsManagerST::Get()->FunctionFromFileLine(iter->getFilename(), iter->getLineNumber());
if(tag) {
scopeName = tag->GetPath();
}
text << linenum << wxT("[ ") << scopeName << wxT(" ] ");
if(lines.GetCount() > iter->getLineNumber()) {
text << lines.Item(iter->getLineNumber()).Trim().Trim(false);
}
text << wxT("\n");
lineNumber++;
}
text << wxString::Format(_("===== Found total of %u matches =====\n"), (unsigned int)m_matches.size());
AppendText(text);
}
