void CompilerMainPage::LoadCompilers()
{
// Populate the compilers list
m_listBoxCompilers->Clear();
wxString cmpType;
if(clCxxWorkspaceST::Get()->IsOpen() && clCxxWorkspaceST::Get()->GetActiveProject()) {
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetActiveProject()->GetBuildConfiguration();
if(bldConf) {
cmpType = bldConf->GetCompilerType();
}
}
BuildSettingsConfigCookie cookie;
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetFirstCompiler(cookie);
int sel(0);
while(cmp) {
int curidx = m_listBoxCompilers->Append(cmp->GetName());
if(!cmpType.IsEmpty() && (cmp->GetName() == cmpType)) {
sel = curidx;
}
cmp = BuildSettingsConfigST::Get()->GetNextCompiler(cookie);
}
if(!m_listBoxCompilers->IsEmpty()) {
m_listBoxCompilers->SetSelection(sel);
LoadCompiler(m_listBoxCompilers->GetStringSelection());
}
}
void AdvancedDlg::OnAddExistingCompiler()
{
wxString folder = ::wxDirSelector(_("Select the compiler folder"));
if(folder.IsEmpty()) {
return;
}
CompilerPtr cmp = m_compilersDetector.Locate(folder);
if(cmp) {
// We found new compiler
// Prompt the user to give it a name
while(true) {
wxString name =
::wxGetTextFromUser(_("Set a name to the compiler"), _("New compiler found!"), cmp->GetName());
if(name.IsEmpty()) {
return;
}
// Add the compiler
if(BuildSettingsConfigST::Get()->IsCompilerExist(name)) {
continue;
}
cmp->SetName(name);
break;
}
// Save the new compiler
BuildSettingsConfigST::Get()->SetCompiler(cmp);
// Reload the dialog
LoadCompilers();
}
}
void NewBuildTab::DoCacheRegexes()
{
m_cmpPatterns.clear();
// Loop over all known compilers and cache the regular expressions
BuildSettingsConfigCookie cookie;
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetFirstCompiler(cookie);
while( cmp ) {
CmpPatterns cmpPatterns;
const Compiler::CmpListInfoPattern& errPatterns = cmp->GetErrPatterns();
const Compiler::CmpListInfoPattern& warnPatterns = cmp->GetWarnPatterns();
Compiler::CmpListInfoPattern::const_iterator iter;
for (iter = errPatterns.begin(); iter != errPatterns.end(); iter++) {
CmpPatternPtr compiledPatternPtr(new CmpPattern(new wxRegEx(iter->pattern), iter->fileNameIndex, iter->lineNumberIndex, SV_ERROR));
if(compiledPatternPtr->GetRegex()->IsValid()) {
cmpPatterns.errorsPatterns.push_back( compiledPatternPtr );
}
}
for (iter = warnPatterns.begin(); iter != warnPatterns.end(); iter++) {
CmpPatternPtr compiledPatternPtr(new CmpPattern(new wxRegEx(iter->pattern), iter->fileNameIndex, iter->lineNumberIndex, SV_WARNING));
if(compiledPatternPtr->GetRegex()->IsValid()) {
cmpPatterns.warningPatterns.push_back( compiledPatternPtr );
}
}
m_cmpPatterns.insert(std::make_pair(cmp->GetName(), cmpPatterns));
cmp = BuildSettingsConfigST::Get()->GetNextCompiler(cookie);
}
}
void PSCompilerPage::OnCustomEditorClicked(wxCommandEvent& event)
{
wxPGProperty* prop = m_pgMgr->GetSelectedProperty();
CHECK_PTR_RET(prop);
m_dlg->SetIsDirty(true);
if ( prop == m_pgPropPreProcessors || prop == m_pgPropIncludePaths || prop == m_pgPropAssembler ) {
wxString value = prop->GetValueAsString();
if ( PopupAddOptionDlg(value) ) {
prop->SetValueFromString( value );
}
} else if ( prop == m_pgPropCppOpts || prop == m_pgPropCOpts ) {
wxString value = prop->GetValueAsString();
wxString cmpName = m_gp->GetCompiler();
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetCompiler(cmpName);
if (PopupAddOptionCheckDlg(value, _("Compiler options"), cmp->GetCompilerOptions())) {
prop->SetValueFromString( value );
}
} else if ( prop == m_pgPropPreCmpHeaderFile ) {
wxFileName curvalue = prop->GetValueAsString();
wxString program = ::wxFileSelector(_("Choose a file"), curvalue.GetPath());
if ( !program.IsEmpty() ) {
program.Replace("\\", "/");
prop->SetValue( program );
}
}
}
void BuildSettingsConfig::SetCompiler(CompilerPtr cmp)
{
wxXmlNode *node = XmlUtils::FindFirstByTagName(m_doc->GetRoot(), wxT("Compilers"));
if(node) {
wxXmlNode *oldCmp = NULL;
wxXmlNode *child = node->GetChildren();
while(child) {
if(child->GetName() == wxT("Compiler") && XmlUtils::ReadString(child, wxT("Name")) == cmp->GetName()) {
oldCmp = child;
break;
}
child = child->GetNext();
}
if(oldCmp) {
node->RemoveChild(oldCmp);
delete oldCmp;
}
node->AddChild(cmp->ToXml());
} else {
wxXmlNode *node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Compilers"));
m_doc->GetRoot()->AddChild(node);
node->AddChild(cmp->ToXml());
}
m_doc->Save(m_fileName.GetFullPath());
}
bool CompilersDetectorManager::FoundMinGWCompiler() const
{
for(size_t i = 0; i < m_compilersFound.size(); ++i) {
CompilerPtr compiler = m_compilersFound.at(i);
if(compiler->GetCompilerFamily() == COMPILER_FAMILY_MINGW) {
// we found at least one MinGW compiler
return true;
}
}
return false;
}
void CompilersFoundDlg::OnItemActivated(wxDataViewEvent& event)
{
CompilerPtr compiler = GetCompiler(event.GetItem());
if(compiler) {
m_defaultCompilers.erase(compiler->GetCompilerFamily());
compiler->SetIsDefault(true);
m_defaultCompilers.insert(std::make_pair(compiler->GetCompilerFamily(), compiler));
m_dataview->UnselectAll();
m_dataview->CallAfter(&wxDataViewCtrl::Refresh, true, (const wxRect*)NULL);
MSWUpdateToolchain(compiler);
}
}
void TagsOptionsDlg::DoSuggest(wxTextCtrl* textCtrl)
{
CompilerPtrVec_t allCompilers = BuildSettingsConfigST::Get()->GetAllCompilers();
// We only support auto retrieval of compilers from the GCC family
wxArrayString compilerNames;
std::for_each(allCompilers.begin(), allCompilers.end(), [&](CompilerPtr c) {
if(c->GetCompilerFamily() == COMPILER_FAMILY_CLANG || c->GetCompilerFamily() == COMPILER_FAMILY_MINGW ||
c->GetCompilerFamily() == COMPILER_FAMILY_GCC) {
compilerNames.Add(c->GetName());
} else if(::clIsCygwinEnvironment() && c->GetCompilerFamily() == COMPILER_FAMILY_CYGWIN) {
compilerNames.Add(c->GetName());
}
});
wxString selection;
if(compilerNames.size() > 1) {
// we have more than one compiler defined, ask the user which one to use
clSingleChoiceDialog dlg(this, compilerNames, 0);
dlg.SetTitle(_("Select the compiler to use:"));
if(dlg.ShowModal() != wxID_OK) return;
selection = dlg.GetSelection();
} else if(compilerNames.size() == 1) {
selection = compilerNames.Item(0);
}
if(selection.IsEmpty()) return;
CompilerPtr comp = BuildSettingsConfigST::Get()->GetCompiler(selection);
CHECK_PTR_RET(comp);
wxArrayString paths;
paths = comp->GetDefaultIncludePaths();
wxString suggestedPaths;
for(size_t i = 0; i < paths.GetCount(); i++) {
suggestedPaths << paths.Item(i) << wxT("\n");
}
suggestedPaths.Trim().Trim(false);
if(!suggestedPaths.IsEmpty()) {
if(::wxMessageBox(_("Accepting this suggestion will replace your old search paths with these paths\nContinue?"),
"CodeLite",
wxYES_NO | wxYES_DEFAULT | wxCANCEL | wxICON_QUESTION) != wxYES) {
return;
}
textCtrl->Clear();
textCtrl->ChangeValue(suggestedPaths);
}
}
NewCompilerDlg::NewCompilerDlg(wxWindow* parent)
: NewCompilerDlgBase(parent)
{
BuildSettingsConfigCookie cookie;
m_choiceCompilers->Append("<None>");
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetFirstCompiler(cookie);
while ( cmp ) {
m_choiceCompilers->Append(cmp->GetName());
cmp = BuildSettingsConfigST::Get()->GetNextCompiler(cookie);
}
m_choiceCompilers->SetStringSelection("<None>");
WindowAttrManager::Load(this, "NewCompilerDlg");
}
void CompilerLocatorCrossGCC::AddTools(CompilerPtr compiler,
const wxString& binFolder,
const wxString& prefix,
const wxString& suffix)
{
compiler->SetName("Cross GCC ( " + prefix + " )");
compiler->SetInstallationPath(binFolder);
CL_DEBUG("Found CrossGCC compiler under: %s. \"%s\"", binFolder, compiler->GetName());
wxFileName toolFile(binFolder, "");
toolFile.SetFullName(prefix + "-g++");
toolFile.SetExt(suffix);
AddTool(compiler, "CXX", toolFile.GetFullPath(), suffix);
AddTool(compiler, "LinkerName", toolFile.GetFullPath());
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), "-shared -fPIC");
toolFile.SetFullName(prefix + "-gcc");
toolFile.SetExt(suffix);
AddTool(compiler, "CC", toolFile.GetFullPath());
toolFile.SetFullName(prefix + "-ar");
toolFile.SetExt(suffix);
AddTool(compiler, "AR", toolFile.GetFullPath(), "rcu");
toolFile.SetFullName(prefix + "-windres");
toolFile.SetExt(suffix);
if(toolFile.FileExists()) AddTool(compiler, "ResourceCompiler", toolFile.GetFullPath());
toolFile.SetFullName(prefix + "-as");
toolFile.SetExt(suffix);
AddTool(compiler, "AS", toolFile.GetFullPath());
toolFile.SetFullName(prefix + "-gdb");
toolFile.SetExt(suffix);
AddTool(compiler, "Debugger", toolFile.GetFullPath());
toolFile.SetFullName("make");
toolFile.SetExt(suffix);
wxString makeExtraArgs;
if(wxThread::GetCPUCount() > 1) {
makeExtraArgs << "-j" << wxThread::GetCPUCount();
}
// XXX Need this on Windows?
// makeExtraArgs << " SHELL=cmd.exe ";
// What to do if there's no make here? (on Windows)
if(toolFile.FileExists()) AddTool(compiler, "MAKE", toolFile.GetFullPath(), makeExtraArgs);
}
void CompilerLocatorGCC::AddTools(CompilerPtr compiler,
const wxString& binFolder,
const wxString& suffix)
{
wxFileName masterPath(binFolder, "");
wxString defaultBinFolder = "/usr/bin";
compiler->SetCompilerFamily(COMPILER_FAMILY_GCC);
compiler->SetInstallationPath( binFolder );
CL_DEBUG("Found GNU GCC compiler under: %s. \"%s\"", masterPath.GetPath(), compiler->GetName());
wxFileName toolFile(binFolder, "");
// ++++-----------------------------------------------------------------
// With XCode installation, only
// g++, gcc, and make are installed under the Xcode installation folder
// the rest (mainly ar and as) are taken from /usr/bin
// ++++-----------------------------------------------------------------
toolFile.SetFullName("g++");
AddTool(compiler, "CXX", toolFile.GetFullPath(), suffix);
AddTool(compiler, "LinkerName", toolFile.GetFullPath(), suffix);
#ifndef __WXMAC__
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), suffix, "-shared -fPIC");
#else
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), suffix, "-dynamiclib -fPIC");
#endif
toolFile.SetFullName("gcc");
AddTool(compiler, "CC", toolFile.GetFullPath(), suffix);
toolFile.SetFullName("make");
wxString makeExtraArgs;
if ( wxThread::GetCPUCount() > 1 ) {
makeExtraArgs << "-j" << wxThread::GetCPUCount();
}
AddTool(compiler, "MAKE", toolFile.GetFullPath(), "", makeExtraArgs);
// ++++-----------------------------------------------------------------
// From this point on, we use /usr/bin only
// ++++-----------------------------------------------------------------
toolFile.AssignDir( defaultBinFolder );
toolFile.SetFullName("ar");
AddTool(compiler, "AR", toolFile.GetFullPath(), "", "rcu");
toolFile.SetFullName("windres");
AddTool(compiler, "ResourceCompiler", "", "");
toolFile.SetFullName("as");
AddTool(compiler, "AS", toolFile.GetFullPath(), "");
}
void CompilerLocatorMinGW::AddTools(CompilerPtr compiler, const wxString& binFolder, const wxString& name)
{
wxFileName masterPath(binFolder, "");
masterPath.RemoveLastDir();
if ( m_locatedFolders.count(masterPath.GetPath()) ) {
return;
}
m_locatedFolders.insert( masterPath.GetPath() );
if ( name.IsEmpty() ) {
compiler->SetName("MinGW ( " + masterPath.GetDirs().Last() + " )");
} else {
compiler->SetName("MinGW ( " + name + " )");
}
CL_DEBUG("Found MinGW compiler under: %s. \"%s\"", masterPath.GetPath(), compiler->GetName());
wxFileName toolFile(binFolder, "");
toolFile.SetFullName("g++.exe");
AddTool(compiler, "CXX", toolFile.GetFullPath());
AddTool(compiler, "LinkerName", toolFile.GetFullPath());
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), "-shared -fPIC");
toolFile.SetFullName("gcc.exe");
AddTool(compiler, "CC", toolFile.GetFullPath());
toolFile.SetFullName("ar.exe");
AddTool(compiler, "AR", toolFile.GetFullPath(), "rcu");
toolFile.SetFullName("windres.exe");
AddTool(compiler, "ResourceCompiler", toolFile.GetFullPath());
toolFile.SetFullName("as.exe");
AddTool(compiler, "AS", toolFile.GetFullPath());
toolFile.SetFullName("make.exe");
if ( toolFile.FileExists() ) {
AddTool(compiler, "MAKE", toolFile.GetFullPath());
} else {
toolFile.SetFullName("mingw32-make.exe");
if ( toolFile.FileExists() ) {
AddTool(compiler, "MAKE", toolFile.GetFullPath());
}
}
}
void CompilerLocatorCLANG::AddTools(CompilerPtr compiler, const wxString &installFolder)
{
compiler->SetInstallationPath( installFolder );
wxFileName toolFile(installFolder, "");
toolFile.AppendDir("bin");
#ifdef __WXMSW__
toolFile.SetExt("exe");
#endif
toolFile.SetName("clang++");
AddTool(compiler, "CXX", toolFile.GetFullPath());
AddTool(compiler, "LinkerName", toolFile.GetFullPath());
#ifdef __WXMAC__
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), "-dynamiclib -fPIC");
#else
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), "-shared -fPIC");
#endif
toolFile.SetName("clang");
AddTool(compiler, "CC", toolFile.GetFullPath());
// Add the archive tool
toolFile.SetName("llvm-ar");
if ( toolFile.FileExists() ) {
AddTool(compiler, "AR", toolFile.GetFullPath(), "rcu");
} else {
toolFile.SetName("ar");
AddTool(compiler, "AR", toolFile.GetFullPath(), "rcu");
}
#ifdef __WXMSW__
AddTool(compiler, "ResourceCompiler", "windres.exe");
#else
AddTool(compiler, "ResourceCompiler", "");
#endif
// Add the assembler tool
toolFile.SetName("llvm-as");
if ( toolFile.FileExists() ) {
AddTool(compiler, "AS", toolFile.GetFullPath());
} else {
toolFile.SetName("as");
AddTool(compiler, "AS", toolFile.GetFullPath());
}
wxString makeExtraArgs;
if ( wxThread::GetCPUCount() > 1 ) {
makeExtraArgs << "-j" << wxThread::GetCPUCount();
}
#ifdef __WXMSW__
AddTool(compiler, "MAKE", "mingw32-make.exe", makeExtraArgs);
#else
AddTool(compiler, "MAKE", "make", makeExtraArgs);
#endif
}
bool AdvancedDlg::CreateNewCompiler(const wxString& name, const wxString& copyFrom)
{
if(BuildSettingsConfigST::Get()->IsCompilerExist(name)) {
wxMessageBox(_("A compiler with this name already exists"), _("Error"), wxOK | wxICON_HAND);
return false;
}
CompilerPtr cmp;
if(!copyFrom.IsEmpty()) {
cmp = BuildSettingsConfigST::Get()->GetCompiler(copyFrom);
} else {
cmp = BuildSettingsConfigST::Get()->GetCompiler(name);
}
cmp->SetName(name);
BuildSettingsConfigST::Get()->SetCompiler(cmp);
return true;
}
CompilerPtr CompilerLocatorCLANG::Locate(const wxString& folder)
{
m_compilers.clear();
wxFileName clang(folder, "clang");
#ifdef __WXMSW__
clang.SetExt("exe");
#endif
bool found = clang.FileExists();
if ( ! found ) {
// try to see if we have a bin folder here
clang.AppendDir("bin");
found = clang.FileExists();
}
if ( found ) {
CompilerPtr compiler( new Compiler(NULL) );
compiler->SetCompilerFamily(COMPILER_FAMILY_CLANG);
// get the compiler version
compiler->SetName( GetCompilerFullName(clang.GetFullPath() ) );
compiler->SetGenerateDependeciesFile(true);
m_compilers.push_back( compiler );
clang.RemoveLastDir();
AddTools(compiler, clang.GetPath());
// Update the toolchain (if Windows)
#ifdef __WXMSW__
CompilerPtr defaultMinGWCmp = BuildSettingsConfigST::Get()->GetDefaultCompiler(COMPILER_FAMILY_MINGW);
if ( defaultMinGWCmp ) {
compiler->SetTool("MAKE", defaultMinGWCmp->GetTool("MAKE"));
compiler->SetTool("ResourceCompiler", defaultMinGWCmp->GetTool("ResourceCompiler"));
// Update the include paths
IncludePathLocator locator(NULL);
wxArrayString includePaths, excludePaths;
locator.Locate(includePaths, excludePaths, false, defaultMinGWCmp->GetTool("CXX"));
// Convert the include paths to semi colon separated list
wxString mingwIncludePaths = wxJoin(includePaths, ';');
compiler->SetGlobalIncludePath( mingwIncludePaths );
}
#endif
return compiler;
}
return NULL;
}
void CompilerLocatorMinGW::AddTool(CompilerPtr compiler, const wxString& toolname, const wxString& toolpath, const wxString& extraArgs)
{
wxString tool = toolpath;
::WrapWithQuotes(tool);
if(!extraArgs.IsEmpty()) {
tool << " " << extraArgs;
}
compiler->SetTool(toolname, tool);
}
void CompilerLocatorCrossGCC::AddTool(CompilerPtr compiler,
const wxString& toolname,
const wxString& toolpath,
const wxString& extraArgs)
{
wxString tool = toolpath;
::WrapWithQuotes(tool);
compiler->SetTool(toolname, tool + " " + extraArgs);
CL_DEBUG("Adding tool: %s => %s", toolname, tool);
}
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() );
}
CompilerLinkerOptionsPage::CompilerLinkerOptionsPage( wxWindow* parent, const wxString &cmpname )
: CompilerLinkerOptionsBase( parent )
, m_cmpname(cmpname)
, m_selectedLnkOption(wxNOT_FOUND)
{
m_listLinkerOptions->InsertColumn(0, wxT("Switch"));
m_listLinkerOptions->InsertColumn(1, wxT("Help"));
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetCompiler(m_cmpname);
const Compiler::CmpCmdLineOptions& lnkOptions = cmp->GetLinkerOptions();
Compiler::CmpCmdLineOptions::const_iterator itLnkOption = lnkOptions.begin();
for ( ; itLnkOption != lnkOptions.end(); ++itLnkOption)
{
const Compiler::CmpCmdLineOption& lnkOption = itLnkOption->second;
long idx = m_listLinkerOptions->InsertItem(m_listLinkerOptions->GetItemCount(), lnkOption.name);
m_listLinkerOptions->SetItem(idx, 1, lnkOption.help);
}
m_listLinkerOptions->SetColumnWidth(0, 100);
m_listLinkerOptions->SetColumnWidth(1, wxLIST_AUTOSIZE);
}
void PSLinkerPage::OnCustomEditorClicked(wxCommandEvent& event)
{
wxPGProperty* prop = m_pgMgr->GetSelectedProperty();
CHECK_PTR_RET(prop);
m_dlg->SetIsDirty(true);
if ( prop == m_pgPropLibraries || prop == m_pgPropLibraryPaths ) {
wxString value = prop->GetValueAsString();
if ( PopupAddOptionDlg(value) ) {
prop->SetValueFromString( value );
}
} else if ( prop == m_pgPropOptions ) {
wxString value = prop->GetValueAsString();
wxString cmpName = m_gp->GetCompiler();
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetCompiler(cmpName);
if (PopupAddOptionCheckDlg(value, _("Linker options"), cmp->GetLinkerOptions())) {
prop->SetValueFromString( value );
}
}
}
void CompilerLocatorCygwin::AddTool(CompilerPtr compiler, const wxString& toolname, const wxString& toolpath, const wxString& extraArgs)
{
wxString tool = toolpath;
::WrapWithQuotes(tool);
// Cygwin does not like backslahes... replace the tools to use /
tool.Replace("\\", "/");
if(!extraArgs.IsEmpty()) {
tool << " " << extraArgs;
}
compiler->SetTool(toolname, tool);
}
void CompilerLocatorGCC::AddTool(CompilerPtr compiler, const wxString& toolname, const wxString& toolpath, const wxString& suffix, const wxString& extraArgs)
{
wxString tool = toolpath;
if ( !suffix.IsEmpty() ) {
tool << "-" << suffix;
}
::WrapWithQuotes(tool);
tool << " " << extraArgs;
compiler->SetTool(toolname, tool);
CL_DEBUG("Adding tool: %s => %s", toolname, tool);
}
bool JudgeTask::compile()
{
ILogger *logger = LoggerFactory::getLogger(LoggerId::AppInitLoggerId);
logger->logTrace(OJStr("[JudgeTask] start compile..."));
CompilerPtr compiler = CompilerFactory::create(Input.Language);
compiler->run(codeFile_, exeFile_, compileFile_);
if(compiler->isAccept())
{
output_.Result = AppConfig::JudgeCode::Accept;
}
else if(compiler->isSystemError())
{
output_.Result = AppConfig::JudgeCode::SystemError;
}
else if(compiler->isCompileError())
{
output_.Result = AppConfig::JudgeCode::CompileError;
std::vector<OJChar_t> buffer;
if(FileTool::ReadFile(buffer, compileFile_) && !buffer.empty())
{
output_.CompileError = &buffer[0];
}
}
return compiler->isAccept();
}
void CompilerLocatorCrossGCC::AddTool(CompilerPtr compiler,
const wxString& toolname,
const wxString& toolpath,
const wxString& extraArgs)
{
wxString tool = toolpath;
::WrapWithQuotes(tool);
if(!extraArgs.IsEmpty()) {
tool << " " << extraArgs;
}
compiler->SetTool(toolname, tool);
CL_DEBUG("Adding tool: %s => %s", toolname, tool);
}
void CompilerMainPage::OnRenameCompiler(wxCommandEvent& event)
{
int selection = m_listBoxCompilers->GetSelection();
if(selection == wxNOT_FOUND) return;
wxString newName =
::wxGetTextFromUser(_("New Compiler Name"), _("Rename Compiler"), m_listBoxCompilers->GetStringSelection());
if(newName.IsEmpty()) return;
CompilerPtr compiler = BuildSettingsConfigST::Get()->GetCompiler(m_listBoxCompilers->GetStringSelection());
if(!compiler) return;
// Delete the old compiler
BuildSettingsConfigST::Get()->DeleteCompiler(compiler->GetName());
// Create new one with differet name
compiler->SetName(newName);
BuildSettingsConfigST::Get()->SetCompiler(compiler);
// Reload the content
LoadCompilers();
}
void CompilerLinkerOptionsPage::Save(CompilerPtr cmp)
{
Compiler::CmpCmdLineOptions lnkOptions;
for (int idx = 0; idx < m_listLinkerOptions->GetItemCount(); ++idx)
{
Compiler::CmpCmdLineOption lnkOption;
lnkOption.name = m_listLinkerOptions->GetItemText(idx);
lnkOption.help = GetColumnText(m_listLinkerOptions, idx, 1);
lnkOptions[lnkOption.name] = lnkOption;
}
cmp->SetLinkerOptions(lnkOptions);
}
CompilersFoundDlg::CompilersFoundDlg(wxWindow* parent, const ICompilerLocator::CompilerVec_t& compilers)
: CompilersFoundDlgBase(parent)
{
m_allCompilers = compilers;
// Replace the model with a custom one
unsigned int colCount = m_dataviewModel->GetColCount();
m_dataviewModel = new MyCompilersFoundModel(this);
m_dataviewModel->SetColCount(colCount);
m_dataview->AssociateModel(m_dataviewModel.get());
// Add the categories
std::map<wxString, wxDataViewItem> categories;
for(size_t i = 0; i < compilers.size(); ++i) {
if(categories.count(compilers.at(i)->GetCompilerFamily()) == 0) {
wxVector<wxVariant> cols;
cols.push_back(compilers.at(i)->GetCompilerFamily());
wxDataViewItem item = m_dataviewModel->AppendItem(wxDataViewItem(0), cols);
categories.insert(std::make_pair(compilers.at(i)->GetCompilerFamily(), item));
}
}
for(size_t i = 0; i < compilers.size(); ++i) {
CompilerPtr compiler = compilers.at(i);
wxDataViewItem parent = categories.find(compiler->GetCompilerFamily())->second;
wxVector<wxVariant> cols;
cols.push_back(compiler->GetName());
cols.push_back(compiler->GetInstallationPath());
m_dataviewModel->AppendItem(parent, cols, new CompilersFoundDlgItemData(compiler));
if(m_defaultCompilers.count(compiler->GetCompilerFamily()) == 0) {
compiler->SetIsDefault(true); // Per family
m_defaultCompilers.insert(std::make_pair(compiler->GetCompilerFamily(), compiler));
MSWUpdateToolchain(compiler);
}
}
std::map<wxString, wxDataViewItem>::iterator iter = categories.begin();
for(; iter != categories.end(); ++iter) {
m_dataview->Expand(iter->second);
}
SetName("CompilersFoundDlg");
WindowAttrManager::Load(this);
}
// do the actual cleanup
void CompileRequest::Process(IManager* manager)
{
wxString cmd;
wxString errMsg;
wxStringMap_t om;
BuildSettingsConfig* bsc(manager ? manager->GetBuildSettingsConfigManager() : BuildSettingsConfigST::Get());
BuildManager* bm(manager ? manager->GetBuildManager() : BuildManagerST::Get());
clCxxWorkspace* w(manager ? manager->GetWorkspace() : clCxxWorkspaceST::Get());
EnvironmentConfig* env(manager ? manager->GetEnv() : EnvironmentConfig::Instance());
ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg);
if(!proj) {
AppendLine(_("Cant find project: ") + m_info.GetProject());
return;
}
wxString pname(proj->GetName());
// BuilderPtr builder = bm->GetBuilder(wxT("GNU makefile for g++/gcc"));
BuilderPtr builder = bm->GetSelectedBuilder();
if(m_fileName.IsEmpty() == false) {
// we got a complie request of a single file
cmd = m_preprocessOnly ?
builder->GetPreprocessFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName, errMsg) :
builder->GetSingleFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName);
} else if(m_info.GetProjectOnly()) {
switch(m_info.GetKind()) {
case QueueCommand::kRebuild:
cmd = builder->GetPORebuildCommand(m_info.GetProject(), m_info.GetConfiguration());
break;
default:
case QueueCommand::kBuild:
cmd = builder->GetPOBuildCommand(m_info.GetProject(), m_info.GetConfiguration());
break;
}
} else {
cmd = builder->GetBuildCommand(m_info.GetProject(), m_info.GetConfiguration());
}
// Notify plugins that a compile process is going to start
clBuildEvent event(wxEVT_BUILD_STARTING);
event.SetProjectName(pname);
event.SetConfigurationName(m_info.GetConfiguration());
if(EventNotifier::Get()->ProcessEvent(event)) {
// the build is being handled by some plugin, no need to build it
// using the standard way
return;
}
// Send the EVENT_STARTED : even if this event is sent, next event will
// be post, so no way to be sure the the build process has not started
SendStartMsg();
// if we require to run the makefile generation command only, replace the 'cmd' with the
// generation command line
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(m_premakeOnly && bldConf) {
BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if(bldConf) {
cmd = bldConf->GetMakeGenerationCommand();
}
}
if(bldConf) {
wxString cmpType = bldConf->GetCompilerType();
CompilerPtr cmp = bsc->GetCompiler(cmpType);
if(cmp) {
// Add the 'bin' folder of the compiler to the PATH environment variable
wxString scxx = cmp->GetTool("CXX");
scxx.Trim().Trim(false);
scxx.StartsWith("\"", &scxx);
scxx.EndsWith("\"", &scxx);
// Strip the double quotes
wxFileName cxx(scxx);
wxString pathvar;
pathvar << cxx.GetPath() << clPATH_SEPARATOR;
// If we have an additional path, add it as well
if(!cmp->GetPathVariable().IsEmpty()) {
pathvar << cmp->GetPathVariable() << clPATH_SEPARATOR;
}
pathvar << "$PATH";
om["PATH"] = pathvar;
}
}
if(cmd.IsEmpty()) {
// if we got an error string, use it
if(errMsg.IsEmpty() == false) {
AppendLine(errMsg);
} else {
AppendLine(_("Command line is empty. Build aborted."));
}
return;
}
WrapInShell(cmd);
DirSaver ds;
DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false);
// expand the variables of the command
cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), m_fileName);
// print the build command
AppendLine(cmd + wxT("\n"));
if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) {
// set working directory
DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false);
}
// print the prefix message of the build start. This is important since the parser relies
// on this message
if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) {
wxString configName(m_info.GetConfiguration());
// also, send another message to the main frame, indicating which project is being built
// and what configuration
wxString text;
text << wxGetTranslation(BUILD_PROJECT_PREFIX) << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]");
if(m_fileName.IsEmpty()) {
text << wxT("----------\n");
} else if(m_preprocessOnly) {
text << wxT(" (Preprocess Single File)----------\n");
} else {
text << wxT(" (Single File Build)----------\n");
}
AppendLine(text);
}
EnvSetter envir(env, &om, proj->GetName());
m_proc = CreateAsyncProcess(this, cmd);
if(!m_proc) {
wxString message;
message << _("Failed to start build process, command: ") << cmd << _(", process terminated with exit code: 0");
AppendLine(message);
return;
}
}
void CompilersDetectorManager::MSWFixClangToolChain(CompilerPtr compiler,
const ICompilerLocator::CompilerVec_t& allCompilers)
{
// Update the toolchain (if Windows)
#ifdef __WXMSW__
ICompilerLocator::CompilerVec_t compilers;
if(allCompilers.empty()) {
BuildSettingsConfigCookie cookie;
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetFirstCompiler(cookie);
while(cmp) {
compilers.push_back(cmp);
cmp = BuildSettingsConfigST::Get()->GetNextCompiler(cookie);
}
} else {
compilers.insert(compilers.end(), allCompilers.begin(), allCompilers.end());
}
if(compiler->GetCompilerFamily() == COMPILER_FAMILY_CLANG) {
for(size_t i = 0; i < compilers.size(); ++i) {
CompilerPtr mingwCmp = compilers.at(i);
if(mingwCmp->GetCompilerFamily() == COMPILER_FAMILY_MINGW) {
compiler->SetTool("MAKE", mingwCmp->GetTool("MAKE"));
compiler->SetTool("ResourceCompiler", mingwCmp->GetTool("ResourceCompiler"));
// Update the include paths
IncludePathLocator locator(NULL);
wxArrayString includePaths, excludePaths;
locator.Locate(includePaths, excludePaths, false, mingwCmp->GetTool("CXX"));
// Convert the include paths to semi colon separated list
wxString mingwIncludePaths = wxJoin(includePaths, ';');
compiler->SetGlobalIncludePath(mingwIncludePaths);
// Keep the mingw's bin path
wxFileName mingwGCC(mingwCmp->GetTool("CXX"));
compiler->SetPathVariable(mingwGCC.GetPath());
break;
}
}
}
#endif
}
void CompilersFoundDlg::MSWUpdateToolchain(CompilerPtr compiler)
{
wxUnusedVar(compiler);
#ifdef __WXMSW__
if(compiler->GetCompilerFamily() == COMPILER_FAMILY_MINGW) {
// Clang and VC lacks 2 tools: make and windres
// so we copy those from the default MinGW compiler
wxString make = compiler->GetTool("MAKE");
wxString resourceCompiler = compiler->GetTool("ResourceCompiler");
for(size_t i = 0; i < m_allCompilers.size(); ++i) {
CompilerPtr c = m_allCompilers.at(i);
if(c->GetCompilerFamily() == COMPILER_FAMILY_CLANG || c->GetCompilerFamily() == COMPILER_FAMILY_VC) {
c->SetTool("MAKE", make);
c->SetTool("ResourceCompiler", resourceCompiler);
if(c->GetCompilerFamily() == COMPILER_FAMILY_CLANG) {
// Clang under Windows, needs the include paths from the MinGW compiler
IncludePathLocator locator(NULL);
wxArrayString includePaths, excludePaths;
locator.Locate(includePaths, excludePaths, false, compiler->GetTool("CXX"));
// Convert the include paths to semi colon separated list
wxString mingwIncludePaths = wxJoin(includePaths, ';');
c->SetGlobalIncludePath(mingwIncludePaths);
}
}
}
}
#endif
}