void ClangCodeCompletion::OnBuildStarting(clBuildEvent& e)
{
e.Skip();
CHECK_CLANG_ENABLED_RET();
// Determine the compilation database
CompilationDatabase cdb;
cdb.Open();
cdb.Close();
// Set the compilation database environment variable
::wxSetEnv(wxT("CL_COMPILATION_DB"), cdb.GetFileName().GetFullPath());
// If this is NOT a custom project, set the CXX and CC environment
wxString project = e.GetProjectName();
wxString config = e.GetConfigurationName();
BuildConfigPtr bldConf = WorkspaceST::Get()->GetProjBuildConf(project, config);
if( bldConf && !bldConf->IsCustomBuild()) {
wxString cxx = bldConf->GetCompiler()->GetTool(wxT("CXX"));
wxString cc = bldConf->GetCompiler()->GetTool(wxT("CC"));
cxx.Prepend(wxT("codelitegcc "));
cc.Prepend(wxT("codelitegcc "));
::wxSetEnv("CXX", cxx);
::wxSetEnv("CC" , cc);
}
}
wxString QMakePlugin::DoGetBuildCommand(const wxString &project, const wxString &config, bool projectOnly)
{
wxUnusedVar ( config );
wxString errMsg;
ProjectPtr p = m_mgr->GetWorkspace()->FindProjectByName(project, errMsg);
if ( !p ) {
return wxEmptyString;
}
BuildConfigPtr bldConf = WorkspaceST::Get()->GetProjBuildConf(project, config);
wxString cmd;
if ( !projectOnly ) {
cmd << wxT("@cd \"") << p->GetFileName().GetPath() << wxT("\" && ");
}
// fix: replace all Windows like slashes to POSIX
wxString command = bldConf->GetCompiler()->GetTool("MAKE");
command.Replace(wxT("\\"), wxT("/"));
cmd << command << wxT(" \"") << p->GetName() << wxT(".mk\"");
return cmd;
}
wxString QMakePlugin::DoGetBuildCommand(const wxString& project, const wxString& config, bool projectOnly)
{
wxUnusedVar(config);
wxString errMsg;
ProjectPtr p = m_mgr->GetWorkspace()->FindProjectByName(project, errMsg);
if(!p) { return wxEmptyString; }
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetProjBuildConf(project, config);
wxString cmd;
wxString projectMakefile;
projectMakefile << p->GetName() << ".mk";
::WrapWithQuotes(projectMakefile);
projectMakefile.Replace("\\", "/");
if(!projectOnly) {
// part of a greater makefile, use $(MAKE)
cmd << wxT("@cd \"") << p->GetFileName().GetPath() << wxT("\" && ");
cmd << "$(MAKE) -f " << projectMakefile;
} else {
// project only
cmd = bldConf->GetCompiler()->GetTool("MAKE");
if(!cmd.Contains("-f")) { cmd << " -f "; }
cmd << " " << projectMakefile;
}
return cmd;
}
void CMakePlugin::DoRunCMake(ProjectPtr p)
{
CHECK_PTR_RET(p);
BuildConfigPtr buildConf = p->GetBuildConfiguration();
CHECK_COND_RET(buildConf);
// Apply the environment variables before we do anything here
#ifdef __WXMSW__
// On Windows, we need to set the bin folder of the selected compiler
wxFileName fnCxx(buildConf->GetCompiler()->GetTool("CXX"));
wxStringMap_t om;
wxString pathvar;
pathvar << fnCxx.GetPath() << clPATH_SEPARATOR << "$PATH";
om["PATH"] = pathvar;
EnvSetter es(NULL, &om, p->GetName(), buildConf->GetName());
#else
EnvSetter es(p);
#endif
CMakeGenerator generator;
if(generator.CanGenerate(p)) {
generator.Generate(p);
}
const wxString& args = buildConf->GetBuildSystemArguments();
wxString cmakeExe = GetCMake()->GetPath().GetFullPath();
// Did the user provide a generator to use?
bool hasGeneratorInArgs = (args.Find(" -G") != wxNOT_FOUND);
// Build the working directory
wxFileName fnWorkingDirectory(CMakeBuilder::GetWorkspaceBuildFolder(false), "");
wxString workingDirectory = fnWorkingDirectory.GetPath();
// Ensure that the build directory exists
fnWorkingDirectory.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
::WrapWithQuotes(cmakeExe);
wxString command;
command << cmakeExe << " .. " << args;
if(!hasGeneratorInArgs) {
#ifdef __WXMSW__
// On Windows, generate MinGW makefiles
command << " -G\"MinGW Makefiles\"";
#endif
}
// Execute it
IProcess* proc = ::CreateAsyncProcess(this, command, IProcessCreateDefault, fnWorkingDirectory.GetPath());
if(!proc) {
::wxMessageBox(_("Failed to execute:\n") + command, "CodeLite", wxICON_ERROR | wxOK | wxCENTER,
EventNotifier::Get()->TopFrame());
return;
}
m_mgr->ShowOutputPane(_("Build"));
m_mgr->ClearOutputTab(kOutputTab_Build);
m_mgr->AppendOutputTabText(kOutputTab_Build, command + "\n");
}
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 NewBuildTab::OnBuildStarted(clCommandEvent& e)
{
e.Skip();
if(IS_WINDOWS) {
m_cygwinRoot.Clear();
EnvSetter es;
wxString cmd;
cmd << "cygpath -w /";
wxArrayString arrOut;
ProcUtils::SafeExecuteCommand(cmd, arrOut);
if(arrOut.IsEmpty() == false) { m_cygwinRoot = arrOut.Item(0); }
}
m_buildInProgress = true;
// Reload the build settings data
EditorConfigST::Get()->ReadObject(wxT("build_tab_settings"), &m_buildTabSettings);
InitView();
m_autoHide = m_buildTabSettings.GetAutoHide();
m_showMe = (BuildTabSettingsData::ShowBuildPane)m_buildTabSettings.GetShowBuildPane();
m_skipWarnings = m_buildTabSettings.GetSkipWarnings();
if(e.GetEventType() != wxEVT_SHELL_COMMAND_STARTED_NOCLEAN) {
DoClear();
DoCacheRegexes();
}
// Show the tab if needed
OutputPane* opane = clMainFrame::Get()->GetOutputPane();
wxWindow* win(NULL);
int sel = opane->GetNotebook()->GetSelection();
if(sel != wxNOT_FOUND) { win = opane->GetNotebook()->GetPage(sel); }
if(m_showMe == BuildTabSettingsData::ShowOnStart) {
ManagerST::Get()->ShowOutputPane(BUILD_WIN, true);
} else if(m_showMe == BuildTabSettingsData::ShowOnEnd && m_autoHide &&
ManagerST::Get()->IsPaneVisible(opane->GetCaption()) && win == this) {
// user prefers to see build/errors tabs only at end of unsuccessful build
ManagerST::Get()->HidePane(opane->GetName());
}
m_sw.Start();
m_cmp.Reset(NULL);
BuildEventDetails* bed = dynamic_cast<BuildEventDetails*>(e.GetClientObject());
if(bed) {
BuildConfigPtr buildConfig =
clCxxWorkspaceST::Get()->GetProjBuildConf(bed->GetProjectName(), bed->GetConfiguration());
if(buildConfig) { m_cmp = buildConfig->GetCompiler(); }
// notify the plugins that the build had started
clBuildEvent buildEvent(wxEVT_BUILD_STARTED);
buildEvent.SetProjectName(bed->GetProjectName());
buildEvent.SetConfigurationName(bed->GetConfiguration());
EventNotifier::Get()->AddPendingEvent(buildEvent);
}
}
bool CodeCompletionManager::GetDefinitionsAndSearchPaths(LEditor* editor,
wxArrayString& searchPaths,
wxArrayString& definitions)
{
// Sanity
CHECK_PTR_RET_FALSE(editor);
if(editor->GetProjectName().IsEmpty())
return false;
if(!WorkspaceST::Get()->IsOpen())
return false;
// Support only C/C++ files
if(!FileExtManager::IsCxxFile(editor->GetFileName().GetFullName()))
return false;
// Get the file's project and get the build configuration settings
// for it
ProjectPtr proj = WorkspaceST::Get()->GetProject(editor->GetProjectName());
CHECK_PTR_RET_FALSE(proj);
BuildConfigPtr buildConf = proj->GetBuildConfiguration();
CHECK_PTR_RET_FALSE(buildConf);
CompilerPtr compiler = buildConf->GetCompiler();
CHECK_PTR_RET_FALSE(compiler);
if(buildConf->IsCustomBuild()) {
// Custom builds are handled differently
CompilationDatabase compileDb;
compileDb.Open();
if(compileDb.IsOpened()) {
// we have compilation database for this workspace
wxString compileLine, cwd;
compileDb.CompilationLine(editor->GetFileName().GetFullPath(), compileLine, cwd);
CL_DEBUG("Pre Processor dimming: %s\n", compileLine);
CompilerCommandLineParser cclp(compileLine, cwd);
searchPaths = cclp.GetIncludes();
// get the mcros
definitions = cclp.GetMacros();
} else {
// we will probably will fail...
return false;
}
} else {
// get the include paths based on the project settings (this is per build configuration)
searchPaths = proj->GetIncludePaths();
CL_DEBUG("CxxPreProcessor will use the following include paths:");
CL_DEBUG_ARR(searchPaths);
// get the compiler include paths
// wxArrayString compileIncludePaths = compiler->GetDefaultIncludePaths();
// includePaths.insert(includePaths.end(), compileIncludePaths.begin(), compileIncludePaths.end());
definitions = proj->GetPreProcessors();
CL_DEBUG("CxxPreProcessor will use the following macros:");
CL_DEBUG_ARR(definitions);
}
// Append the compiler builtin macros
wxArrayString builtinMacros = compiler->GetBuiltinMacros();
definitions.insert(definitions.end(), builtinMacros.begin(), builtinMacros.end());
return true;
}
bool CodeCompletionManager::GetDefinitionsAndSearchPaths(clEditor* editor, wxArrayString& searchPaths,
wxArrayString& definitions)
{
// Sanity
CHECK_PTR_RET_FALSE(editor);
if(editor->GetProjectName().IsEmpty()) return false;
if(!clCxxWorkspaceST::Get()->IsOpen()) return false;
// Support only C/C++ files
if(!FileExtManager::IsCxxFile(editor->GetFileName().GetFullName())) return false;
// Get the file's project and get the build configuration settings
// for it
ProjectPtr proj = clCxxWorkspaceST::Get()->GetProject(editor->GetProjectName());
CHECK_PTR_RET_FALSE(proj);
BuildConfigPtr buildConf = proj->GetBuildConfiguration();
CHECK_PTR_RET_FALSE(buildConf);
CompilerPtr compiler = buildConf->GetCompiler();
CHECK_PTR_RET_FALSE(compiler);
#if 0
if(buildConf->IsCustomBuild()) {
definitions = proj->GetPreProcessors();
CL_DEBUG("CxxPreProcessor will use the following macros:");
CL_DEBUG_ARR(definitions);
// Custom builds are handled differently
CompilationDatabase compileDb;
compileDb.Open();
if(compileDb.IsOpened()) {
// we have compilation database for this workspace
wxString compileLine, cwd;
compileDb.CompilationLine(editor->GetFileName().GetFullPath(), compileLine, cwd);
CL_DEBUG("Pre Processor dimming: %s\n", compileLine);
CompilerCommandLineParser cclp(compileLine, cwd);
searchPaths = cclp.GetIncludes();
// get the mcros
definitions << cclp.GetMacros();
}
}
#endif
// get the include paths based on the project settings (this is per build configuration)
searchPaths = proj->GetIncludePaths();
CL_DEBUG("CxxPreProcessor will use the following include paths:");
CL_DEBUG_ARR(searchPaths);
// get the compiler include paths
// wxArrayString compileIncludePaths = compiler->GetDefaultIncludePaths();
// includePaths.insert(includePaths.end(), compileIncludePaths.begin(), compileIncludePaths.end());
definitions = proj->GetPreProcessors();
// get macros out of workspace
wxString strWorkspaceMacros = clCxxWorkspaceST::Get()->GetParserMacros();
wxArrayString workspaceMacros = wxStringTokenize(strWorkspaceMacros, wxT("\n\r"), wxTOKEN_STRTOK);
for(size_t i = 0; i < workspaceMacros.GetCount(); i++)
definitions.Add(workspaceMacros.Item(i).Trim().Trim(false).c_str());
CL_DEBUG("CxxPreProcessor will use the following macros:");
CL_DEBUG_ARR(definitions);
// Append the compiler builtin macros
wxArrayString builtinMacros = compiler->GetBuiltinMacros();
definitions.insert(definitions.end(), builtinMacros.begin(), builtinMacros.end());
return true;
}
