void clCxxWorkspace::AddProjectToBuildMatrix(ProjectPtr prj)
{
if(!prj) {
wxMessageBox(_("AddProjectToBuildMatrix was called with NULL project"), _("CodeLite"), wxICON_WARNING | wxOK);
return;
}
BuildMatrixPtr matrix = GetBuildMatrix();
wxString selConfName = matrix->GetSelectedConfigurationName();
std::list<WorkspaceConfigurationPtr> wspList = matrix->GetConfigurations();
std::list<WorkspaceConfigurationPtr>::iterator iter = wspList.begin();
for(; iter != wspList.end(); iter++) {
WorkspaceConfigurationPtr workspaceConfig = (*iter);
WorkspaceConfiguration::ConfigMappingList prjList = workspaceConfig->GetMapping();
wxString wspCnfName = workspaceConfig->GetName();
ProjectSettingsCookie cookie;
// getSettings is a bit misleading, since it actually create new instance which represents the layout
// of the XML
ProjectSettingsPtr settings = prj->GetSettings();
BuildConfigPtr prjBldConf = settings->GetFirstBuildConfiguration(cookie);
BuildConfigPtr matchConf;
if(!prjBldConf) {
// the project does not have any settings, create new one and add it
prj->SetSettings(settings);
settings = prj->GetSettings();
prjBldConf = settings->GetFirstBuildConfiguration(cookie);
matchConf = prjBldConf;
} else {
matchConf = prjBldConf;
// try to locate the best match to add to the workspace
while(prjBldConf) {
wxString projBldConfName = prjBldConf->GetName();
if(wspCnfName == projBldConfName) {
// we found a suitable match use it instead of the default one
matchConf = prjBldConf;
break;
}
prjBldConf = settings->GetNextBuildConfiguration(cookie);
}
}
ConfigMappingEntry entry(prj->GetName(), matchConf->GetName());
prjList.push_back(entry);
(*iter)->SetConfigMappingList(prjList);
matrix->SetConfiguration((*iter));
}
// and set the configuration name
matrix->SetSelectedConfigurationName(selConfName);
// this will also reset the build matrix pointer
SetBuildMatrix(matrix);
}
bool WSImporter::Import(wxString& errMsg)
{
wxString compileName = defaultCompiler.Lower();
bool isGccCompile = compileName.Contains(wxT("gnu")) || compileName.Contains(wxT("gcc")) ||
compileName.Contains(wxT("g++")) || compileName.Contains(wxT("mingw"));
for(std::shared_ptr<GenericImporter> importer : importers) {
if(importer->OpenWordspace(filename, defaultCompiler)) {
if(importer->isSupportedWorkspace()) {
GenericWorkspacePtr gworskspace = importer->PerformImport();
wxString errMsgLocal;
bool showDlg = true;
if(!clCxxWorkspaceST::Get()->CreateWorkspace(gworskspace->name, gworskspace->path, errMsgLocal))
return false;
clCxxWorkspace* clWorkspace = NULL;
WorkspaceConfiguration::ConfigMappingList cmlDebug;
WorkspaceConfiguration::ConfigMappingList cmlRelease;
for(GenericProjectPtr project : gworskspace->projects) {
GenericCfgType cfgType = project->cfgType;
wxString projectType, errMsg;
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
projectType = Project::DYNAMIC_LIBRARY;
break;
case GenericCfgType::STATIC_LIBRARY:
projectType = Project::STATIC_LIBRARY;
break;
case GenericCfgType::EXECUTABLE:
default:
projectType = Project::EXECUTABLE;
break;
}
if(!clCxxWorkspaceST::Get()->CreateProject(project->name, project->path, projectType, true, errMsg))
return false;
ProjectPtr proj = clCxxWorkspaceST::Get()->FindProjectByName(project->name, errMsg);
ProjectSettingsPtr le_settings(new ProjectSettings(NULL));
le_settings->RemoveConfiguration(wxT("Debug"));
le_settings->SetProjectType(projectType);
if(clWorkspace == NULL)
clWorkspace = proj->GetWorkspace();
for(GenericProjectCfgPtr cfg : project->cfgs) {
BuildConfigPtr le_conf(new BuildConfig(NULL));
wxString outputFileName = wxT("");
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += DYNAMIC_LIBRARY_EXT;
break;
case GenericCfgType::STATIC_LIBRARY:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += STATIC_LIBRARY_EXT;
if(isGccCompile && outputFileName.Contains(wxT(".lib"))) {
outputFileName.Replace(wxT(".lib"), wxT(".a"));
}
break;
case GenericCfgType::EXECUTABLE:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += EXECUTABLE_EXT;
break;
}
std::vector<wxString> envVarElems;
le_conf->SetName(cfg->name);
if(!cfg->includePath.IsEmpty()) {
envVarElems.push_back(cfg->includePath);
le_conf->SetIncludePath(cfg->includePath);
}
if(!cfg->libraries.IsEmpty()) {
envVarElems.push_back(cfg->libraries);
if(isGccCompile && cfg->libraries.Contains(wxT(".lib"))) {
cfg->libraries.Replace(wxT(".lib"), wxT(".a"));
}
le_conf->SetLibraries(cfg->libraries);
}
if(!cfg->libPath.IsEmpty()) {
envVarElems.push_back(cfg->libPath);
le_conf->SetLibPath(cfg->libPath);
}
if(!cfg->preprocessor.IsEmpty()) {
envVarElems.push_back(cfg->preprocessor);
le_conf->SetPreprocessor(cfg->preprocessor);
}
if(!cfg->intermediateDirectory.IsEmpty())
le_conf->SetIntermediateDirectory(cfg->intermediateDirectory);
if(!cfg->outputFilename.IsEmpty()) {
if(isGccCompile && cfg->outputFilename.Contains(wxT(".lib"))) {
cfg->outputFilename.Replace(wxT(".lib"), wxT(".a"));
}
le_conf->SetOutputFileName(cfg->outputFilename);
} else
le_conf->SetOutputFileName(outputFileName);
if(!cfg->cCompilerOptions.IsEmpty())
le_conf->SetCCompileOptions(cfg->cCompilerOptions);
if(!cfg->cppCompilerOptions.IsEmpty())
le_conf->SetCompileOptions(cfg->cppCompilerOptions);
if(!cfg->linkerOptions.IsEmpty())
le_conf->SetLinkOptions(cfg->linkerOptions);
if(!cfg->preCompiledHeader.IsEmpty())
le_conf->SetPrecompiledHeader(cfg->preCompiledHeader);
wxString outputFileNameCommand, outputFileNameWorkingDirectory;
if(!cfg->outputFilename.IsEmpty()) {
wxFileName outputFileNameInfo(cfg->outputFilename);
outputFileNameCommand = wxT("./") + outputFileNameInfo.GetFullName();
outputFileNameWorkingDirectory = outputFileNameInfo.GetPath();
outputFileNameWorkingDirectory.Replace(wxT("\\"), wxT("/"));
}
if(!cfg->command.IsEmpty())
le_conf->SetCommand(cfg->command);
else if(!outputFileNameCommand.IsEmpty())
le_conf->SetCommand(outputFileNameCommand);
else
le_conf->SetCommand(wxT("./$(ProjectName)"));
if(!cfg->workingDirectory.IsEmpty())
le_conf->SetWorkingDirectory(cfg->workingDirectory);
else if(!outputFileNameWorkingDirectory.IsEmpty())
le_conf->SetWorkingDirectory(outputFileNameWorkingDirectory);
else
le_conf->SetWorkingDirectory(wxT("./$(IntermediateDirectory)"));
le_conf->SetCompilerType(defaultCompiler);
wxString cfgName = cfg->name.Lower();
if(cfgName.Contains(wxT("debug"))) {
ConfigMappingEntry cme(project->name, cfg->name);
cmlDebug.push_back(cme);
} else if(cfgName.Contains(wxT("release"))) {
ConfigMappingEntry cme(project->name, cfg->name);
cmlRelease.push_back(cme);
} else {
ConfigMappingEntry cme(project->name, cfg->name);
cmlDebug.push_back(cme);
cmlRelease.push_back(cme);
}
wxString buildConfigType;
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
buildConfigType = Project::DYNAMIC_LIBRARY;
break;
case GenericCfgType::STATIC_LIBRARY:
buildConfigType = Project::STATIC_LIBRARY;
break;
case GenericCfgType::EXECUTABLE:
default:
buildConfigType = Project::EXECUTABLE;
break;
}
le_conf->SetProjectType(buildConfigType);
if(showDlg) {
if(envVarElems.size() > 0 && ContainsEnvVar(envVarElems)) {
std::set<wxString> listEnvVar = GetListEnvVarName(envVarElems);
for(GenericEnvVarsValueType envVar : cfg->envVars) {
listEnvVar.erase(envVar.first);
}
if(listEnvVar.size() > 0) {
EnvVarImporterDlg envVarImporterDlg(
NULL, project->name, cfg->name, listEnvVar, le_conf, &showDlg);
envVarImporterDlg.ShowModal();
}
}
}
wxString envVars =
!le_conf->GetEnvvars().IsEmpty() ? le_conf->GetEnvvars() + wxT("\n") : wxT("");
for(GenericEnvVarsValueType envVar : cfg->envVars) {
envVars += envVar.first + wxT("=") + envVar.second + wxT("\n");
}
le_conf->SetEnvvars(envVars);
BuildCommandList preBuildCommandList;
BuildCommandList postBuildCommandList;
for (wxString preBuildCmd : cfg->preBuildCommands) {
BuildCommand preBuildCommand;
preBuildCommand.SetCommand(preBuildCmd);
preBuildCommand.SetEnabled(true);
preBuildCommandList.push_back(preBuildCommand);
}
for (wxString postBuildCmd : cfg->postBuildCommands) {
BuildCommand postBuildCommand;
postBuildCommand.SetCommand(postBuildCmd);
postBuildCommand.SetEnabled(true);
postBuildCommandList.push_back(postBuildCommand);
}
le_conf->SetPreBuildCommands(preBuildCommandList);
le_conf->SetPostBuildCommands(postBuildCommandList);
le_settings->SetBuildConfiguration(le_conf);
if(!project->deps.IsEmpty())
proj->SetDependencies(project->deps, cfg->name);
}
proj->SetSettings(le_settings);
proj->BeginTranscation();
// Delete default virtual directory
proj->DeleteVirtualDir("include");
proj->DeleteVirtualDir("src");
for(GenericProjectFilePtr file : project->files) {
wxString vpath;
if(file->vpath.IsEmpty()) {
wxFileName fileInfo(file->name);
wxString ext = fileInfo.GetExt().Lower();
if(ext == wxT("h") || ext == wxT("hpp") || ext == wxT("hxx") || ext == wxT("hh") ||
ext == wxT("inl") || ext == wxT("inc")) {
vpath = wxT("include");
} else if(ext == wxT("c") || ext == wxT("cpp") || ext == wxT("cxx") || ext == wxT("cc")) {
vpath = wxT("src");
} else if(ext == wxT("s") || ext == wxT("S") || ext == wxT("asm")) {
vpath = wxT("src");
} else {
vpath = wxT("resource");
}
} else {
vpath = file->vpath;
if(file->vpath.Contains(wxT("\\"))) {
vpath.Replace(wxT("\\"), wxT(":"));
} else if(file->vpath.Contains(wxT("/"))) {
vpath.Replace(wxT("/"), wxT(":"));
}
}
proj->CreateVirtualDir(vpath);
proj->AddFile(file->name, vpath);
}
proj->CommitTranscation();
}
if(clWorkspace) {
BuildMatrixPtr clMatrix = clWorkspace->GetBuildMatrix();
WorkspaceConfigurationPtr wsconf = clMatrix->GetConfigurationByName(wxT("Debug"));
if(wsconf) {
wsconf->SetConfigMappingList(cmlDebug);
}
wsconf = clMatrix->GetConfigurationByName(wxT("Release"));
if(wsconf) {
wsconf->SetConfigMappingList(cmlRelease);
}
clWorkspace->SetBuildMatrix(clMatrix);
}
return true;
}
}
}
return false;
}