wxString MemCheckPlugin::PrepareCommand(const wxString& projectName, wxString& wd)
{
wd.clear();
if(!clCxxWorkspaceST::Get()->IsOpen()) { return ""; }
ProjectPtr proj = clCxxWorkspaceST::Get()->GetProject(projectName);
if(!proj) {
clWARNING() << "MemCheckPlugin::PrepareCommand(): could not find project:" << projectName;
return wxEmptyString;
}
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetProjBuildConf(projectName, wxEmptyString);
if(!bldConf) {
clWARNING() << "MemCheckPlugin::PrepareCommand(): failed to find project configuration for project:"
<< projectName;
return wxEmptyString;
}
wxString projectPath = proj->GetFileName().GetPath();
// expand variables
wxString cmd = bldConf->GetCommand();
cmd = MacroManager::Instance()->Expand(cmd, NULL, projectName);
wxString cmdArgs = bldConf->GetCommandArguments();
cmdArgs = MacroManager::Instance()->Expand(cmdArgs, NULL, projectName);
// Execute command & cmdArgs
wd = bldConf->GetWorkingDirectory();
wd = MacroManager::Instance()->Expand(wd, NULL, projectName);
wxFileName workingDir(wd, "");
if(workingDir.IsRelative()) { workingDir.MakeAbsolute(projectPath); }
wxFileName fileExe(cmd);
if(fileExe.IsRelative()) { fileExe.MakeAbsolute(workingDir.GetPath()); }
fileExe.Normalize();
#ifdef __WXMSW__
if(!fileExe.Exists() && fileExe.GetExt().IsEmpty()) {
// Try with .exe
wxFileName withExe(fileExe);
withExe.SetExt("exe");
if(withExe.Exists()) { fileExe = withExe; }
}
#endif
wd = workingDir.GetPath();
cmd = fileExe.GetFullPath();
cmd = ::WrapWithQuotes(cmd);
cmd << " " << cmdArgs;
clDEBUG() << "Command to execute:" << cmd;
clDEBUG() << "Working directory:" << wd;
return cmd;
}
void PSGeneralPage::Load(BuildConfigPtr buildConf)
{
Clear();
m_configName = buildConf->GetName();
m_checkBoxEnabled->SetValue( buildConf->IsProjectEnabled() );
m_pgPropArgs->SetValue( buildConf->GetCommandArguments() );
m_pgPropDebugArgs->SetValueFromString( buildConf->GetDebugArgs() );
m_pgPropIntermediateFolder->SetValueFromString( buildConf->GetIntermediateDirectory() );
m_pgPropGUIApp->SetValue( buildConf->IsGUIProgram() );
m_pgPropOutputFile->SetValueFromString( buildConf->GetOutputFileName() );
m_pgPropPause->SetValue( buildConf->GetPauseWhenExecEnds() );
m_pgPropProgram->SetValueFromString( buildConf->GetCommand() );
m_pgPropWorkingDirectory->SetValue( buildConf->GetWorkingDirectory() );
// Project type
wxPGChoices choices;
choices.Add(Project::STATIC_LIBRARY);
choices.Add(Project::DYNAMIC_LIBRARY);
choices.Add(Project::EXECUTABLE);
m_pgPropProjectType->SetChoices( choices );
m_pgPropProjectType->SetChoiceSelection( choices.Index(buildConf->GetProjectType() ) );
// Compilers
choices.Clear();
wxString cmpType = buildConf->GetCompilerType();
BuildSettingsConfigCookie cookie;
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetFirstCompiler(cookie);
while (cmp) {
choices.Add(cmp->GetName());
cmp = BuildSettingsConfigST::Get()->GetNextCompiler(cookie);
}
m_pgPropCompiler->SetChoices( choices );
m_pgPropCompiler->SetChoiceSelection( choices.Index( buildConf->GetCompiler()->GetName() ) );
// Debuggers
choices.Clear();
wxString dbgType = buildConf->GetDebuggerType();
wxArrayString dbgs = DebuggerMgr::Get().GetAvailableDebuggers();
choices.Add(dbgs);
m_pgPropDebugger->SetChoices( choices );
m_pgPropDebugger->SetChoiceSelection( choices.Index(buildConf->GetDebuggerType()) );
m_pgPropUseSeparateDebuggerArgs->SetValue( buildConf->GetUseSeparateDebugArgs() );
m_dlg->SetIsProjectEnabled( buildConf->IsProjectEnabled() );
}
void LLDBPlugin::OnDebugStart(clDebugEvent& event)
{
if(event.GetDebuggerName() != LLDB_DEBUGGER_NAME) {
event.Skip();
return;
}
CL_DEBUG("LLDB: Initial working directory is restored to: " + ::wxGetCwd());
{
// Get the executable to debug
wxString errMsg;
ProjectPtr pProject = clCxxWorkspaceST::Get()->FindProjectByName(event.GetProjectName(), errMsg);
if(!pProject) {
::wxMessageBox(wxString() << _("Could not locate project: ") << event.GetProjectName(), "LLDB Debugger",
wxICON_ERROR | wxOK | wxCENTER);
return;
}
DirSaver ds;
::wxSetWorkingDirectory(pProject->GetFileName().GetPath());
// Load LLDB settings
LLDBSettings settings;
settings.Load();
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetProjBuildConf(pProject->GetName(), wxEmptyString);
if(!bldConf) {
::wxMessageBox(wxString() << _("Could not locate the requested buid configuration"), "LLDB Debugger",
wxICON_ERROR | wxOK | wxCENTER);
return;
}
// Launch codelite-lldb now.
// Choose wether we need to debug a local or remote target
// Honour the project settings
if(bldConf->GetIsDbgRemoteTarget()) {
long nPort(wxNOT_FOUND);
bldConf->GetDbgHostPort().ToCLong(&nPort);
settings.SetProxyIp(bldConf->GetDbgHostName());
settings.SetProxyPort(nPort);
settings.EnableFlag(kLLDBOptionUseRemoteProxy, true);
}
if(!settings.IsUsingRemoteProxy()) {
// Not using a remote proxy, launch the debug server
if(!m_connector.LaunchLocalDebugServer(settings.GetDebugserver())) { return; }
}
// Determine the executable to debug, working directory and arguments
EnvSetter env(NULL, NULL, pProject ? pProject->GetName() : wxString(), bldConf->GetName());
wxString exepath = bldConf->GetCommand();
wxString args;
wxString workingDirectory;
// Get the debugging arguments.
if(bldConf->GetUseSeparateDebugArgs()) {
args = bldConf->GetDebugArgs();
} else {
args = bldConf->GetCommandArguments();
}
workingDirectory = ::ExpandVariables(bldConf->GetWorkingDirectory(), pProject, m_mgr->GetActiveEditor());
exepath = ::ExpandVariables(exepath, pProject, m_mgr->GetActiveEditor());
{
DirSaver ds;
::wxSetWorkingDirectory(workingDirectory);
wxFileName execToDebug(exepath);
if(execToDebug.IsRelative()) { execToDebug.MakeAbsolute(); }
//////////////////////////////////////////////////////////////////////
// Launch terminal for IO redirection
//////////////////////////////////////////////////////////////////////
TerminateTerminal();
bool isWindows = wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_WINDOWS;
if(!bldConf->IsGUIProgram() && !isWindows) {
m_debuggerTerminal.Launch(clDebuggerTerminalPOSIX::MakeExeTitle(execToDebug.GetFullPath(), args));
if(m_debuggerTerminal.IsValid()) {
CL_DEBUG("Successfully launched terminal %s", m_debuggerTerminal.GetTty());
} else {
// Failed to launch it...
DoCleanup();
::wxMessageBox(_("Failed to start terminal for debugger"), "CodeLite",
wxICON_ERROR | wxOK | wxCENTER);
return;
}
}
if(!isWindows) { workingDirectory = ::wxGetCwd(); }
CL_DEBUG("LLDB: Using executable : " + execToDebug.GetFullPath());
CL_DEBUG("LLDB: Working directory: " + workingDirectory);
//////////////////////////////////////////////////////////////////////
// Initiate the connection to codelite-lldb
//////////////////////////////////////////////////////////////////////
LLDBConnectReturnObject retObj;
if(m_connector.Connect(retObj, settings, 5)) {
// Get list of breakpoints and add them ( we will apply them later on )
BreakpointInfo::Vec_t gdbBps;
m_mgr->GetAllBreakpoints(gdbBps);
// remove all breakpoints from previous session
m_connector.DeleteAllBreakpoints();
// apply the serialized breakpoints
m_connector.AddBreakpoints(gdbBps);
// Setup pivot folder if needed
SetupPivotFolder(retObj);
LLDBCommand startCommand;
startCommand.FillEnvFromMemory();
// If the current platform is Windows, use the executable as it appears in the project settings
startCommand.SetExecutable(isWindows ? exepath : execToDebug.GetFullPath());
startCommand.SetCommandArguments(args);
// Since we called 'wxSetWorkingDirectory' earlier, wxGetCwd() should give use the
// correct working directory for the debugger
startCommand.SetWorkingDirectory(workingDirectory);
startCommand.SetRedirectTTY(m_debuggerTerminal.GetTty());
m_connector.Start(startCommand);
clDebugEvent cl_event(wxEVT_DEBUG_STARTED);
EventNotifier::Get()->AddPendingEvent(cl_event);
} else {
// Failed to connect, notify and perform cleanup
DoCleanup();
wxString message;
message << _("Could not connect to codelite-lldb at '")
<< (settings.IsUsingRemoteProxy() ? settings.GetTcpConnectString()
: m_connector.GetConnectString())
<< "'";
::wxMessageBox(message, "CodeLite", wxICON_ERROR | wxOK | wxCENTER);
return;
}
}
}
CL_DEBUG("LLDB: Working directory is restored to: " + ::wxGetCwd());
}
void CallGraph::OnShowCallGraph(wxCommandEvent& event)
{
// myLog("wxThread::IsMain(%d)", (int)wxThread::IsMain());
IConfigTool *config_tool = m_mgr->GetConfigTool();
config_tool->ReadObject(wxT("CallGraph"), &confData);
if (!wxFileExists(GetGprofPath()) || !wxFileExists(GetDotPath()))
return MessageBox(_T("Failed to locate required tools (gprof, dot). Please check the plugin settings."), wxICON_ERROR);
Workspace *ws = m_mgr->GetWorkspace();
if (!ws) return MessageBox(_("Unable to get opened workspace."), wxICON_ERROR);
wxFileName ws_cfn = ws->GetWorkspaceFileName();
wxString projectName = ws->GetActiveProjectName();
BuildMatrixPtr mtx = ws->GetBuildMatrix();
if (!mtx) return MessageBox(_("Unable to get current build matrix."), wxICON_ERROR);
wxString build_config_name = mtx->GetSelectedConfigurationName();
BuildConfigPtr bldConf = ws->GetProjBuildConf(projectName, build_config_name);
if (!bldConf) return MessageBox(_("Unable to get opened workspace."), wxICON_ERROR);
wxString projOutputFn = bldConf->GetOutputFileName();
wxString projWorkingDir = bldConf->GetWorkingDirectory();
/*
myLog("WorkspaceFileName = \"%s\"", ws_cfn.GetFullPath());
myLog("projectName \"%s\"", projectName);
myLog("build_config_name = \"%s\"", build_config_name);
myLog("projOutputFn = \"%s\"", projOutputFn);
myLog("projWorkingDir = \"%s\"", projWorkingDir);
*/
wxFileName cfn(ws_cfn.GetPath(), projOutputFn);
cfn.Normalize();
// base path
const wxString base_path = ws_cfn.GetPath();
// check source binary exists
wxString bin_fpath = cfn.GetFullPath();
if (!cfn.Exists()) {
bin_fpath = wxFileSelector("Please select the binary to analyze", base_path, "", "");
if (bin_fpath.IsEmpty()) return MessageBox("selected binary was canceled", wxICON_ERROR);
cfn.Assign(bin_fpath, wxPATH_NATIVE);
}
if (!cfn.IsFileExecutable()) return MessageBox("bin/exe isn't executable", wxICON_ERROR);
// check 'gmon.out' file exists
wxFileName gmon_cfn(base_path, GMON_FILENAME_OUT);
if (!gmon_cfn.Exists())
gmon_cfn.Normalize();
wxString gmonfn = gmon_cfn.GetFullPath();
if (!gmon_cfn.Exists()) {
gmonfn = wxFileSelector("Please select the gprof file", gmon_cfn.GetPath(), "gmon", "out");
if (gmonfn.IsEmpty()) return MessageBox("selected gprof was canceled", wxICON_ERROR);
gmon_cfn.Assign(gmonfn, wxPATH_NATIVE);
}
wxString bin, arg1, arg2;
bin = GetGprofPath();
arg1 = bin_fpath;
arg2 = gmonfn;
wxString cmdgprof = wxString::Format("%s %s %s", bin, arg1, arg2);
// myLog("about to wxExecute(\"%s\")", cmdgprof);
wxProcess *proc = new wxProcess(wxPROCESS_REDIRECT);
// wxStopWatch sw;
const int err = ::wxExecute(cmdgprof, wxEXEC_SYNC, proc);
// on sync returns 0 (success), -1 (failure / "couldn't be started")
// myLog("wxExecute() returned err %d, had pid %d", err, (int)proc->GetPid());
wxInputStream *process_is = proc->GetInputStream();
if (!process_is || !process_is->CanRead())
return MessageBox(_("wxProcess::GetInputStream() can't be opened, aborting"), wxICON_ERROR);
// start parsing and writing to dot language file
GprofParser pgp;
pgp.GprofParserStream(process_is);
// myLog("gprof done (read %d lines)", (int) pgp.lines.GetCount());
delete proc;
ConfCallGraph conf;
config_tool->ReadObject(wxT("CallGraph"), &conf);
DotWriter dotWriter;
// DotWriter
dotWriter.SetLineParser(&(pgp.lines));
int suggestedThreshold = pgp.GetSuggestedNodeThreshold();
if (suggestedThreshold <= conf.GetTresholdNode()) {
suggestedThreshold = conf.GetTresholdNode();
dotWriter.SetDotWriterFromDialogSettings(m_mgr);
} else {
dotWriter.SetDotWriterFromDetails(conf.GetColorsNode(),
conf.GetColorsEdge(),
suggestedThreshold,
conf.GetTresholdEdge(),
conf.GetHideParams(),
conf.GetStripParams(),
conf.GetHideNamespaces());
wxString suggest_msg = wxString::Format(_("The CallGraph plugin has suggested node threshold %d to speed-up the call graph creation. You can alter it on the call graph panel."), suggestedThreshold);
MessageBox(suggest_msg, wxICON_INFORMATION);
}
dotWriter.WriteToDotLanguage();
// build output dir
cfn.Assign(base_path, "");
cfn.AppendDir(CALLGRAPH_DIR);
cfn.Normalize();
if (!cfn.DirExists()) cfn.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
cfn.SetFullName(DOT_FILENAME_TXT);
wxString dot_fn = cfn.GetFullPath();
dotWriter.SendToDotAppOutputDirectory(dot_fn);
cfn.SetFullName(DOT_FILENAME_PNG);
wxString output_png_fn = cfn.GetFullPath();
// delete any existing PNG
if (wxFileExists(output_png_fn)) wxRemoveFile(output_png_fn);
wxString cmddot_ln;
cmddot_ln << GetDotPath() << " -Tpng -o" << output_png_fn << " " << dot_fn;
// myLog("wxExecute(\"%s\")", cmddot_ln);
wxExecute(cmddot_ln, wxEXEC_SYNC);
// myLog("dot done");
if (!wxFileExists(output_png_fn))
return MessageBox(_("Failed to open file CallGraph.png. Please check the project settings, rebuild the project and try again."), wxICON_INFORMATION);
// show image and create table in the editor tab page
uicallgraphpanel *panel = new uicallgraphpanel(m_mgr->GetEditorPaneNotebook(), m_mgr, output_png_fn, base_path, suggestedThreshold, &(pgp.lines));
wxString tstamp = wxDateTime::Now().Format(wxT(" %Y-%m-%d %H:%M:%S"));
wxString title = wxT("Call graph for \"") + output_png_fn + wxT("\" " + tstamp);
m_mgr->AddEditorPage(panel, title);
}
void DebugCoreDumpDlg::Initialize()
{
DebugCoreDumpInfo info;
EditorConfigST::Get()->ReadObject(wxT("DebugCoreDumpDlg"), &info);
m_choiceDebuggers->Append(DebuggerMgr::Get().GetAvailableDebuggers());
if(m_choiceDebuggers->GetCount()) {
m_choiceDebuggers->SetSelection(0);
}
if(m_choiceDebuggers->GetCount() > (unsigned int)info.GetSelectedDbg()) {
m_choiceDebuggers->SetSelection(info.GetSelectedDbg());
}
m_Core->Append(info.GetCoreFilepaths());
if(m_Core->GetCount() > 0) {
m_Core->SetSelection(0);
}
m_WD->Append(info.GetWds());
if(m_WD->GetCount() > 0) {
m_WD->SetSelection(0);
}
m_ExeFilepath->Append(info.GetExeFilepaths());
if(m_ExeFilepath->GetCount() > 0) {
m_ExeFilepath->SetSelection(0);
} else {
// determine the executable to debug:
// - If the 'Program' field is set - we use it
// - Else we use the project's output name
wxString activename, conf;
ManagerST::Get()->GetActiveProjectAndConf(activename, conf);
BuildConfigPtr buildConf = WorkspaceST::Get()->GetProjBuildConf(activename, conf);
if(buildConf) {
// expand all macros with their values
wxString programToDebug = buildConf->GetCommand();
programToDebug.Trim().Trim(false);
if(programToDebug.IsEmpty()) {
programToDebug = buildConf->GetOutputFileName();
}
wxString outputFile =
MacroManager::Instance()->Expand(programToDebug, PluginManager::Get(), activename, conf);
if(m_ExeFilepath->Append(outputFile) != wxNOT_FOUND) {
m_ExeFilepath->SetSelection(0);
}
// determine the working directory
// if we have a working directory set in the project settings, use it (if it is not an
// absolute path, it will be appended to the project's path)
wxString projWD = MacroManager::Instance()->Expand(
buildConf->GetWorkingDirectory(), PluginManager::Get(), activename, conf);
projWD.Trim().Trim(false);
wxString wd;
ProjectPtr proj = ManagerST::Get()->GetProject(activename);
if(proj) {
if(projWD.IsEmpty() || !wxFileName(projWD).IsAbsolute()) {
wxString basePath = proj->GetFileName().GetPath();
wd << basePath << wxFileName::GetPathSeparator();
}
}
wd << projWD;
if(m_WD->Insert(wd, 0) != wxNOT_FOUND) {
m_WD->SetSelection(0);
}
}
}
}
wxString MacroManager::DoExpand(
const wxString& expression, IManager* manager, const wxString& project, bool applyEnv, const wxString& confToBuild)
{
wxString expandedString(expression);
clCxxWorkspace* workspace = clCxxWorkspaceST::Get();
if(!manager) {
manager = clGetManager();
}
size_t retries = 0;
wxString dummyname, dummfullname;
while((retries < 5) && FindVariable(expandedString, dummyname, dummyname)) {
++retries;
DollarEscaper de(expandedString);
if(workspace) {
expandedString.Replace(wxT("$(WorkspaceName)"), workspace->GetName());
ProjectPtr proj = workspace->GetProject(project);
if(proj) {
wxString prjBuildWd;
wxString prjRunWd;
wxString project_name(proj->GetName());
// make sure that the project name does not contain any spaces
project_name.Replace(wxT(" "), wxT("_"));
BuildConfigPtr bldConf = workspace->GetProjBuildConf(proj->GetName(), confToBuild);
if(bldConf) {
bool isCustom = bldConf->IsCustomBuild();
expandedString.Replace(wxT("$(ProjectOutputFile)"), bldConf->GetOutputFileName());
// An alias
expandedString.Replace(wxT("$(OutputFile)"), bldConf->GetOutputFileName());
// When custom build project, use the working directory set in the
// custom build tab, otherwise use the project file's path
prjBuildWd = isCustom ? bldConf->GetCustomBuildWorkingDir() : proj->GetFileName().GetPath();
prjRunWd = bldConf->GetWorkingDirectory();
}
expandedString.Replace(wxT("$(ProjectWorkingDirectory)"), prjBuildWd);
expandedString.Replace(wxT("$(ProjectRunWorkingDirectory)"), prjRunWd);
expandedString.Replace(wxT("$(ProjectPath)"), proj->GetFileName().GetPath());
expandedString.Replace(wxT("$(WorkspacePath)"), workspace->GetWorkspaceFileName().GetPath());
expandedString.Replace(wxT("$(ProjectName)"), project_name);
if(bldConf) {
expandedString.Replace(wxT("$(IntermediateDirectory)"), bldConf->GetIntermediateDirectory());
expandedString.Replace(wxT("$(ConfigurationName)"), bldConf->GetName());
expandedString.Replace(wxT("$(OutDir)"), bldConf->GetIntermediateDirectory());
}
if(expandedString.Find(wxT("$(ProjectFiles)")) != wxNOT_FOUND)
expandedString.Replace(wxT("$(ProjectFiles)"), proj->GetFiles());
if(expandedString.Find(wxT("$(ProjectFilesAbs)")) != wxNOT_FOUND)
expandedString.Replace(wxT("$(ProjectFilesAbs)"), proj->GetFiles(true));
}
}
if(manager) {
IEditor* editor = manager->GetActiveEditor();
if(editor) {
wxFileName fn(editor->GetFileName());
expandedString.Replace(wxT("$(CurrentFileName)"), fn.GetName());
wxString fpath(fn.GetPath());
fpath.Replace(wxT("\\"), wxT("/"));
expandedString.Replace(wxT("$(CurrentFilePath)"), fpath);
expandedString.Replace(wxT("$(CurrentFileExt)"), fn.GetExt());
expandedString.Replace(wxT("$(CurrentFileFullName)"), fn.GetFullName());
wxString ffullpath(fn.GetFullPath());
ffullpath.Replace(wxT("\\"), wxT("/"));
expandedString.Replace(wxT("$(CurrentFileFullPath)"), ffullpath);
expandedString.Replace(wxT("$(CurrentSelection)"), editor->GetSelection());
if(expandedString.Find(wxT("$(CurrentSelectionRange)")) != wxNOT_FOUND) {
int start = editor->GetSelectionStart(), end = editor->GetSelectionEnd();
wxString output = wxString::Format(wxT("%i:%i"), start, end);
expandedString.Replace(wxT("$(CurrentSelectionRange)"), output);
}
}
}
// exapand common macros
wxDateTime now = wxDateTime::Now();
expandedString.Replace(wxT("$(User)"), wxGetUserName());
expandedString.Replace(wxT("$(Date)"), now.FormatDate());
if(manager && applyEnv) {
expandedString.Replace(wxT("$(CodeLitePath)"), manager->GetInstallDirectory());
// Apply the environment and expand the variables
EnvSetter es(NULL, NULL, project, confToBuild);
expandedString = manager->GetEnv()->ExpandVariables(expandedString, false);
}
}
return expandedString;
}
