void DebuggerManager::ProcessSettings(RegisteredPlugins::iterator it)
{
cbDebuggerPlugin *plugin = it->first;
PluginData &data = it->second;
ConfigManager *config = Manager::Get()->GetConfigManager(wxT("debugger_common"));
wxString path = wxT("/sets/") + plugin->GetSettingsName();
wxArrayString configs = config->EnumerateSubPaths(path);
configs.Sort();
if (configs.empty())
{
config->Write(path + wxT("/conf1/name"), wxString(wxT("Default")));
configs = config->EnumerateSubPaths(path);
configs.Sort();
}
data.ClearConfigurations();
data.m_lastConfigID = -1;
for (size_t jj = 0; jj < configs.Count(); ++jj)
{
wxString configPath = path + wxT("/") + configs[jj];
wxString name = config->Read(configPath + wxT("/name"));
cbDebuggerConfiguration *pluginConfig;
pluginConfig = plugin->LoadConfig(ConfigManagerWrapper(wxT("debugger_common"), configPath + wxT("/values")));
if (pluginConfig)
{
pluginConfig->SetName(name);
data.GetConfigurations().push_back(pluginConfig);
}
}
}
wxString nsEnvVars::GetSetPathByName(const wxString& set_name, bool check_exists,
bool return_default)
{
#if defined(TRACE_ENVVARS)
Manager::Get()->GetLogManager()->DebugLog(F(_T("GetSetPathByName")));
#endif
wxString set_path = _T("/sets/")+nsEnvVars::EnvVarsDefault; // fall back solution
if (!return_default)
set_path.Empty();
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("envvars"));
if (!cfg || set_path.IsEmpty())
return set_path;
if (!check_exists)
return _T("/sets/")+set_name;
// Read all envvar sets available
wxArrayString sets = cfg->EnumerateSubPaths(_T("/sets"));
unsigned int num_sets = sets.GetCount();
for (unsigned int i=0; i<num_sets; ++i)
{
if (set_name.IsSameAs(sets[i]))
{
set_path = (_T("/sets/")+set_name);
break; // Early exit of for-loop
}
}
return set_path;
}// GetSetPathByName
void ToolsManager::SaveTools()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("tools"));
wxArrayString list = cfg->EnumerateSubPaths(_("/"));
for (unsigned int i = 0; i < list.GetCount(); ++i)
{
cfg->DeleteSubPath(list[i]);
}
int count = 0;
for (ToolsList::Node* node = m_Tools.GetFirst(); node; node = node->GetNext())
{
cbTool* tool = node->GetData();
wxString elem;
// prepend a 0-padded 2-digit number to keep ordering
wxString tmp;
tmp.Printf(_T("tool%2.2d"), count++);
elem << _T("/") << tmp << _T("/");
cfg->Write(elem + _T("name"), tool->GetName());
cfg->Write(elem + _T("command"), tool->GetCommand());
cfg->Write(elem + _T("params"), tool->GetParams());
cfg->Write(elem + _T("workingDir"), tool->GetWorkingDir());
cfg->Write(elem + _T("launchOption"), static_cast<int>(tool->GetLaunchOption()));
}
}
void FilesGroupsAndMasks::Load()
{
Clear();
ConfigManager* conf = Manager::Get()->GetConfigManager(_T("project_manager"));
wxArrayString list = conf->EnumerateSubPaths(_T("/file_groups"));
for (unsigned int i = 0; i < list.GetCount(); ++i)
{
// new way (reading groups)
wxString key = _T("/file_groups/") + list[i];
unsigned int group = AddGroup(conf->Read(key + _T("/name")));
SetFileMasks(group, conf->Read(key + _T("/mask")));
}
}
void CompilerFactory::RegisterUserCompilers()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("compiler"));
wxArrayString paths = cfg->EnumerateSubPaths(_T("/user_sets"));
for (unsigned int i = 0; i < paths.GetCount(); ++i)
{
wxString base = _T("/user_sets/") + paths[i];
wxString parent = cfg->Read(base + _T("/parent"), wxEmptyString);
if (!parent.IsEmpty())
{
Compiler* compiler = GetCompiler(parent);
wxString name = cfg->Read(base + _T("/name"), wxEmptyString);
CreateCompilerCopy(compiler, name);
}
}
}
void ResultMap::ReadDetectedResults()
{
Clear();
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("lib_finder"));
if ( !cfg ) return;
wxArrayString Results = cfg->EnumerateSubPaths(_T("/stored_results"));
for ( size_t i=0; i<Results.Count(); i++ )
{
wxString Path = _T("/stored_results/") + Results[i] + _T("/");
LibraryResult* Result = new LibraryResult();
Result->Type = rtDetected;
Result->LibraryName = cfg->Read(Path+_T("name"),wxEmptyString);
Result->ShortCode = cfg->Read(Path+_T("short_code"),wxEmptyString);
Result->BasePath = cfg->Read(Path+_T("base_path"),wxEmptyString);
Result->Description = cfg->Read(Path+_T("description"),wxEmptyString);
Result->PkgConfigVar = cfg->Read(Path+_T("pkg_config_var"),wxEmptyString);
Result->Categories = cfg->ReadArrayString(Path+_T("categories"));
Result->IncludePath = cfg->ReadArrayString(Path+_T("include_paths"));
Result->LibPath = cfg->ReadArrayString(Path+_T("lib_paths"));
Result->ObjPath = cfg->ReadArrayString(Path+_T("obj_paths"));
Result->Libs = cfg->ReadArrayString(Path+_T("libs"));
Result->Defines = cfg->ReadArrayString(Path+_T("defines"));
Result->CFlags = cfg->ReadArrayString(Path+_T("cflags"));
Result->LFlags = cfg->ReadArrayString(Path+_T("lflags"));
Result->Compilers = cfg->ReadArrayString(Path+_T("compilers"));
Result->Headers = cfg->ReadArrayString(Path+_T("headers"));
Result->Require = cfg->ReadArrayString(Path+_T("require"));
if ( Result->ShortCode.IsEmpty() )
{
delete Result;
continue;
}
GetShortCode(Result->ShortCode).Add(Result);
}
}
void ToolsManager::LoadTools()
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("tools"));
wxArrayString list = cfg->EnumerateSubPaths(_("/"));
for (unsigned int i = 0; i < list.GetCount(); ++i)
{
cbTool tool;
tool.SetName( cfg->Read(_T("/") + list[i] + _T("/name")));
if (tool.GetName().IsEmpty())
continue;
tool.SetCommand(cfg->Read(_T("/") + list[i] + _T("/command")));
if (tool.GetCommand().IsEmpty())
continue;
tool.SetParams(cfg->Read(_T("/") + list[i] + _T("/params")));
tool.SetWorkingDir(cfg->Read(_T("/") + list[i] + _T("/workingDir")));
tool.SetLaunchOption(static_cast<cbTool::eLaunchOption>(cfg->ReadInt(_T("/") + list[i] + _T("/launchOption"))));
AddTool(&tool, false);
}
Manager::Get()->GetLogManager()->Log(F(_("Configured %d tools"), m_Tools.GetCount()));
}
wxArrayString nsEnvVars::GetEnvvarSetNames()
{
#if defined(TRACE_ENVVARS)
Manager::Get()->GetLogManager()->DebugLog(F(_T("GetEnvvarSetNames")));
#endif
wxArrayString set_names;
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("envvars"));
if (!cfg)
{
set_names.Add(nsEnvVars::EnvVarsDefault);
return set_names;
}
// Read all envvar sets available
wxArrayString sets = cfg->EnumerateSubPaths(_T("/sets"));
unsigned int num_sets = sets.GetCount();
EV_DBGLOG(_T("EnvVars: Found %u envvar sets in config."), num_sets);
if (num_sets==0)
set_names.Add(nsEnvVars::EnvVarsDefault);
else
{
for (unsigned int i=0; i<num_sets; ++i)
{
wxString set_name = sets[i];
if (set_name.IsEmpty())
set_name.Printf(_T("Set%u"), i);
set_names.Add(set_name);
}// for
}// if
return set_names;
}// GetEnvvarSetNames
ConfigManagerWrapper DebuggerManager::NewConfig(cbDebuggerPlugin *plugin, cb_unused const wxString& name)
{
RegisteredPlugins::iterator it = m_registered.find(plugin);
if (it == m_registered.end())
return ConfigManagerWrapper();
wxString path = wxT("/sets/") + it->first->GetSettingsName();
if (it->second.m_lastConfigID == -1)
{
ConfigManager *config = Manager::Get()->GetConfigManager(wxT("debugger_common"));
wxArrayString configs = config->EnumerateSubPaths(path);
for (size_t ii = 0; ii < configs.GetCount(); ++ii)
{
long id;
if (configs[ii].Remove(0, 4).ToLong(&id))
it->second.m_lastConfigID = std::max<long>(it->second.m_lastConfigID, id);
}
}
path << wxT("/conf") << ++it->second.m_lastConfigID;
return ConfigManagerWrapper(wxT("debugger_common"), path + wxT("/values"));
}
void Compiler::LoadSettings(const wxString& baseKey)
{
// before loading any compiler settings, keep the current settings safe
// so we can compare them when saving: this way we can only save what's
// different from the defaults
MirrorCurrentSettings();
ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("compiler"));
// read settings version
wxString version = cfg->Read(_T("settings_version"));
bool versionMismatch = version != CompilerSettingsVersion;
wxString tmp;
// if using old-style keys (using integer IDs), notify user about the changes
static bool saidAboutCompilerIDs = false;
tmp.Printf(_T("%s/set%3.3d"), baseKey.c_str(), CompilerFactory::GetCompilerIndex(this) + 1);
if (cfg->Exists(tmp + _T("/name")))
{
if (!saidAboutCompilerIDs)
{
saidAboutCompilerIDs = true;
cbMessageBox(_("Compilers now use unique names instead of integer IDs.\n"
"Projects will be updated accordingly on load, mostly automatic."),
_("Information"),
wxICON_INFORMATION);
}
// at this point, we 'll be using the old style configuration to load settings
}
else // it's OK to use new style
tmp.Printf(_T("%s/%s"), baseKey.c_str(), m_ID.c_str());
if (!cfg->Exists(tmp + _T("/name")))
return;
wxString sep = wxFileName::GetPathSeparator();
m_Name = cfg->Read(tmp + _T("/name"), m_Name);
m_MasterPath = cfg->Read(tmp + _T("/master_path"), m_MasterPath);
m_ExtraPaths = MakeUniqueArray(GetArrayFromString(cfg->Read(tmp + _T("/extra_paths"), _T("")), _T(";")), true);
m_Programs.C = cfg->Read(tmp + _T("/c_compiler"), m_Programs.C);
m_Programs.CPP = cfg->Read(tmp + _T("/cpp_compiler"), m_Programs.CPP);
m_Programs.LD = cfg->Read(tmp + _T("/linker"), m_Programs.LD);
m_Programs.LIB = cfg->Read(tmp + _T("/lib_linker"), m_Programs.LIB);
m_Programs.WINDRES = cfg->Read(tmp + _T("/res_compiler"), m_Programs.WINDRES);
m_Programs.MAKE = cfg->Read(tmp + _T("/make"), m_Programs.MAKE);
m_Programs.DBG = cfg->Read(tmp + _T("/debugger"), m_Programs.DBG);
// set member variable containing the version string with the configurated toolchain executables, not only
// with the default ones, otherwise we might have an empty version-string
// Some MinGW installations do not includee "mingw32-gcc" !!
SetVersionString();
SetCompilerOptions (GetArrayFromString(cfg->Read(tmp + _T("/compiler_options"), wxEmptyString)));
SetLinkerOptions (GetArrayFromString(cfg->Read(tmp + _T("/linker_options"), wxEmptyString)));
SetIncludeDirs (GetArrayFromString(cfg->Read(tmp + _T("/include_dirs"), wxEmptyString)));
SetResourceIncludeDirs(GetArrayFromString(cfg->Read(tmp + _T("/res_include_dirs"), wxEmptyString)));
SetLibDirs (GetArrayFromString(cfg->Read(tmp + _T("/library_dirs"), wxEmptyString)));
SetLinkLibs (GetArrayFromString(cfg->Read(tmp + _T("/libraries"), wxEmptyString)));
SetCommandsBeforeBuild(GetArrayFromString(cfg->Read(tmp + _T("/commands_before"), wxEmptyString)));
SetCommandsAfterBuild (GetArrayFromString(cfg->Read(tmp + _T("/commands_after"), wxEmptyString)));
for (int i = 0; i < ctCount; ++i)
{
wxArrayString keys = cfg->EnumerateSubPaths(tmp + _T("/macros/") + CommandTypeDescriptions[i]);
for (size_t n = 0; n < keys.size(); ++n)
{
unsigned long index = 0;
if (keys[n].Mid(4).ToULong(&index)) // skip 'tool'
{
while (index >= m_Commands[i].size())
m_Commands[i].push_back(CompilerTool());
CompilerTool& tool = m_Commands[i][index];
wxString key = wxString::Format(_T("%s/macros/%s/tool%lu/"), tmp.c_str(), CommandTypeDescriptions[i].c_str(), index);
tool.command = cfg->Read(key + _T("command"));
tool.extensions = cfg->ReadArrayString(key + _T("extensions"));
tool.generatedFiles = cfg->ReadArrayString(key + _T("generatedFiles"));
}
}
}
// switches
m_Switches.includeDirs = cfg->Read(tmp + _T("/switches/includes"), m_Switches.includeDirs);
m_Switches.libDirs = cfg->Read(tmp + _T("/switches/libs"), m_Switches.libDirs);
m_Switches.linkLibs = cfg->Read(tmp + _T("/switches/link"), m_Switches.linkLibs);
m_Switches.defines = cfg->Read(tmp + _T("/switches/define"), m_Switches.defines);
m_Switches.genericSwitch = cfg->Read(tmp + _T("/switches/generic"), m_Switches.genericSwitch);
m_Switches.objectExtension = cfg->Read(tmp + _T("/switches/objectext"), m_Switches.objectExtension);
m_Switches.needDependencies = cfg->ReadBool(tmp + _T("/switches/deps"), m_Switches.needDependencies);
m_Switches.forceCompilerUseQuotes = cfg->ReadBool(tmp + _T("/switches/forceCompilerQuotes"), m_Switches.forceCompilerUseQuotes);
m_Switches.forceLinkerUseQuotes = cfg->ReadBool(tmp + _T("/switches/forceLinkerQuotes"), m_Switches.forceLinkerUseQuotes);
m_Switches.logging = (CompilerLoggingType)cfg->ReadInt(tmp + _T("/switches/logging"), m_Switches.logging);
m_Switches.libPrefix = cfg->Read(tmp + _T("/switches/libPrefix"), m_Switches.libPrefix);
m_Switches.libExtension = cfg->Read(tmp + _T("/switches/libExtension"), m_Switches.libExtension);
m_Switches.linkerNeedsLibPrefix = cfg->ReadBool(tmp + _T("/switches/linkerNeedsLibPrefix"), m_Switches.linkerNeedsLibPrefix);
m_Switches.linkerNeedsLibExtension = cfg->ReadBool(tmp + _T("/switches/linkerNeedsLibExtension"), m_Switches.linkerNeedsLibExtension);
m_Switches.forceFwdSlashes = cfg->ReadBool(tmp + _T("/switches/forceFwdSlashes"), m_Switches.forceFwdSlashes);
m_Switches.supportsPCH = cfg->ReadBool(tmp + _T("/switches/supportsPCH"), m_Switches.supportsPCH);
m_Switches.PCHExtension = cfg->Read(tmp + _T("/switches/pchExtension"), m_Switches.PCHExtension);
m_Switches.UseFlatObjects = cfg->ReadBool(tmp + _T("/switches/UseFlatObjects"), m_Switches.UseFlatObjects);
m_Switches.UseFullSourcePaths = cfg->ReadBool(tmp + _T("/switches/UseFullSourcePaths"), m_Switches.UseFullSourcePaths);
m_Switches.Use83Paths = cfg->ReadBool(tmp + _T("/switches/Use83Paths"), m_Switches.Use83Paths);
// regexes
// because we 're only saving changed regexes, we can't just iterate like before.
// instead, we must iterate all child-keys and deduce the regex index number from
// the key name
wxArrayString keys = cfg->EnumerateSubPaths(tmp + _T("/regex/"));
wxString group;
long index = 0;
for (size_t i = 0; i < keys.GetCount(); ++i)
{
wxString key = keys[i];
// reNNN
if (!key.StartsWith(_T("re")))
continue;
key.Remove(0, 2);
if (!key.ToLong(&index, 10))
continue;
// 'index' now holds the regex index.
// read everything and either assign it to an existing regex
// if the index exists, or add a new regex
group.Printf(_T("%s/regex/re%3.3ld"), tmp.c_str(), index);
if (!cfg->Exists(group+_T("/description")))
continue;
RegExStruct rs;
rs.desc = cfg->Read(group + _T("/description"));
rs.lt = (CompilerLineType)cfg->ReadInt(group + _T("/type"), 0);
rs.regex = cfg->Read(group + _T("/regex"));
rs.msg[0 ] = cfg->ReadInt(group + _T("/msg1"), 0);
rs.msg[1] = cfg->ReadInt(group + _T("/msg2"), 0);
rs.msg[2] = cfg->ReadInt(group + _T("/msg3"), 0);
rs.filename = cfg->ReadInt(group + _T("/filename"), 0);
rs.line = cfg->ReadInt(group + _T("/line"), 0);
if (index <= (long)m_RegExes.GetCount())
m_RegExes[index - 1] = rs;
else
m_RegExes.Add(rs);
}
// custom vars
wxString configpath = tmp + _T("/custom_variables/");
UnsetAllVars();
wxArrayString list = cfg->EnumerateKeys(configpath);
for (unsigned int i = 0; i < list.GetCount(); ++i)
SetVar(list[i], cfg->Read(configpath + _T('/') + list[i]), false);
if (versionMismatch)
{
wxString msg;
msg << _("Some compiler settings defaults have changed in this version.\n"
"It is recommended that you allow updating of your settings to the new defaults.\n"
"Only disallow this if you don't want to lose any customizations you have done to this compiler's settings.\n\n"
"Note that the only settings that are affected are those found in \"Advanced compiler options\"...\n\n"
"Do you want to update your current settings to the new defaults?");
// don't ask if the compiler is not valid (i.e. not installed), just update
if (!IsValid() || cbMessageBox(msg, m_Name, wxICON_QUESTION | wxYES_NO) == wxID_YES)
{
for (int i = 0; i < ctCount; ++i)
m_Commands[i] = m_Mirror.Commands[i];
m_Switches = m_Mirror.Switches;
m_Options = m_Mirror.Options;
m_RegExes = m_Mirror.RegExes;
}
}
}