TiXmlElement* ConfigManager::AssertPath(wxString& path)
{
Collapse(path);
wxString illegal(_T(" -:.\"\'$&()[]<>+#"));
size_t i = 0;
while ((i = path.find_first_of(illegal, i)) != wxString::npos)
path[i] = _T('_');
TiXmlElement *localPath = pathNode ? pathNode : root;
if (path.GetChar(0) == '/') // absolute path
{
localPath = root;
path = path.Mid(1);
}
if (path.find(_T('/')) != wxString::npos) // need for path walking
to_lower(path);
wxString sub;
while (path.find(_T('/')) != wxString::npos)
{
sub = path.BeforeFirst(_T('/'));
path = path.AfterFirst(_T('/'));
if (localPath != root && sub.IsSameAs(CfgMgrConsts::dotDot))
localPath = localPath->Parent()->ToElement();
else if (sub.GetChar(0) < _T('a') || sub.GetChar(0) > _T('z'))
{
cbThrow(InvalidNameMessage(_T("subpath"), sub, localPath));
}
else
{
TiXmlElement* n = localPath->FirstChildElement(cbU2C(sub));
if (n)
localPath = n;
else
localPath = (TiXmlElement*) localPath->InsertEndChild(TiXmlElement(cbU2C(sub)));
}
}
to_upper(path);
if (!path.IsEmpty() && (path.GetChar(0) < _T('A') || path.GetChar(0) > _T('Z')))
cbThrow(InvalidNameMessage(_T("key"), path, localPath));
return localPath;
}
ConfigManager* CfgMgrBldr::Build(const wxString& name_space)
{
if (name_space.IsEmpty())
cbThrow(_T("You attempted to get a ConfigManager instance without providing a namespace."));
wxCriticalSectionLocker locker(cs);
NamespaceMap::iterator it = namespaces.find(name_space);
if (it != namespaces.end())
return it->second;
TiXmlElement* docroot;
if (name_space.StartsWith(_T("volatile:")))
{
if (!volatile_doc)
{
volatile_doc = new TiXmlDocument();
volatile_doc->InsertEndChild(TiXmlElement("CodeBlocksConfig"));
volatile_doc->SetCondenseWhiteSpace(false);
}
docroot = volatile_doc->FirstChildElement("CodeBlocksConfig");
}
else
{
docroot = doc->FirstChildElement("CodeBlocksConfig");
if (!docroot)
{
wxString err(_("Fatal error parsing supplied configuration file.\nParser error message:\n"));
err << wxString::Format(_T("%s\nAt row %d, column: %d."), cbC2U(doc->ErrorDesc()).c_str(), doc->ErrorRow(), doc->ErrorCol());
cbThrow(err);
}
}
TiXmlElement* root = docroot->FirstChildElement(cbU2C(name_space));
if (!root) // namespace does not exist
{
docroot->InsertEndChild(TiXmlElement(cbU2C(name_space)));
root = docroot->FirstChildElement(cbU2C(name_space));
}
if (!root) // now what!
cbThrow(_T("Unable to create namespace in document tree (actually not possible..?)"));
ConfigManager *c = new ConfigManager(root);
namespaces[name_space] = c;
return c;
}
void AnnoyingDialog::OnButton(wxCommandEvent& event)
{
if(!m_CheckBox)
cbThrow(_T("Ow... null pointer."));
int id = event.GetId();
// convert IDs from standard buttons to dReturnType
switch (id)
{
case wxID_YES:
id = rtYES;
break;
case wxID_OK:
id = rtOK;
break;
case wxID_NO:
id = rtNO;
break;
case wxID_CANCEL:
id = rtCANCEL;
break;
default:
break;
}
if(m_CheckBox->IsChecked())
{
ConfigManager* cfg = Manager::Get()->GetConfigManager(wxT("an_dlg"));
ConfigManagerContainer::StringSet disabled = cfg->ReadSSet(wxT("/disabled_ret"));
// if we are supposed to remember the users choice, save the button
disabled.insert(m_Id + F(wxT(":%d"), m_DefRet == rtSAVE_CHOICE ? id : m_DefRet));
cfg->Write(wxT("/disabled_ret"), disabled);
}
EndModal(id);
}
void Compiler::GenerateCommandLine(wxString& macro,
ProjectBuildTarget* target,
ProjectFile* pf,
const wxString& file,
const wxString& object,
const wxString& FlatObject,
const wxString& deps)
{
if (!m_pGenerator)
cbThrow(_T("Compiler::Init() not called or generator invalid!"));
m_pGenerator->GenerateCommandLine(macro, target, pf, file, object, FlatObject, deps);
}
void AnnoyingDialog::OnButton(wxCommandEvent& event)
{
if(!cb)
cbThrow(_T("Ow... null pointer."));
if(cb->IsChecked())
{
ConfigManagerContainer::StringSet disabled = Manager::Get()->GetConfigManager(_T("an_dlg"))->ReadSSet(_T("/disabled"));
disabled.insert(GetTitle());
Manager::Get()->GetConfigManager(_T("an_dlg"))->Write(_T("/disabled"), disabled);
}
EndModal(event.GetId());
}
WizPageBase::WizPageBase(const wxString& pageName, wxWizard* parent, const wxBitmap& bitmap)
: wxWizardPageSimple(parent, 0, 0, bitmap),
m_PageName(pageName)
{
// duplicate pageIDs are not allowed
if (s_PagesByName[m_PageName])
cbThrow(_T("Page ID in use:") + pageName);
// register this to the static pages map
s_PagesByName[m_PageName] = this;
// if this is true, the page won't be added to the wizard
m_SkipPage = Manager::Get()->GetConfigManager(_T("scripts"))->ReadBool(_T("/generic_wizard/") + m_PageName + _T("/skip"), false);
}
void Compiler::MakeValidID()
{
// basically, make it XML-element compatible
// only allow a-z, 0-9 and _
// (it is already lowercase)
// any non-conformant character will be removed
wxString newID;
if (m_ID.IsEmpty())
m_ID = m_Name;
size_t pos = 0;
while (pos < m_ID.Length())
{
wxChar ch = m_ID[pos];
if (wxIsalnum(ch) || ch == _T('_')) // valid character
newID.Append(ch);
else if (wxIsspace(ch)) // convert spaces to underscores
newID.Append(_T('_'));
++pos;
}
// make sure it's not starting with a number.
// if it is, prepend "cb"
if (wxIsdigit(newID.GetChar(0)))
newID.Prepend(_T("cb"));
if (newID.IsEmpty()) // empty? wtf?
cbThrow(_T("Can't create a valid compiler ID for ") + m_Name);
m_ID = newID.Lower();
// check for unique ID
if (!IsUniqueID(m_ID))
cbThrow(_T("Compiler ID already exists for ") + m_Name);
m_CompilerIDs.Add(m_ID);
}
Manager* Manager::Get(wxFrame *appWindow)
{
if (appWindow)
{
if (Get()->m_pAppWindow)
cbThrow(_T("Illegal argument to Manager::Get()"));
else
{
Get()->m_pAppWindow = appWindow;
LoadResource(_T("manager_resources.zip"));
Get()->GetLogManager()->Log(_("Manager initialized"));
}
}
return Get();
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
// TODO (thomas#1#): The non-Windows implementation is *pathetic*.
// However, I don't know how to do it well under GTK / X / Xinerama / whatever.
// Anyone?
{
int the_mode;
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if(!referenceWindow) // let's not crash on shutdown
return;
if(!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if(!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
if(mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
if(the_mode == pdlCentre || the_mode == pdlHead)
{
w->CentreOnScreen();
return;
}
else
{
wxRect windowRect = w->GetRect();
wxRect parentRect = referenceWindow->GetRect(); // poo again!
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, parentRect.x);
x2 = std::min(x2, parentRect.GetRight());
y1 = std::max(y1, parentRect.y);
y2 = std::min(y2, parentRect.GetBottom());
w->SetSize(x1, y1, x2-x1, y2-y1, wxSIZE_ALLOW_MINUS_ONE);
}
}
void ConfigManager::DeleteAll()
{
CfgMgrBldr * bld = CfgMgrBldr::Get();
wxString ns(cbC2U(root->Value()));
if (!ns.IsSameAs(_T("app")))
cbThrow(_T("Illegal attempt to invoke DeleteAll()."));
wxCriticalSectionLocker(bld->cs);
doc->RootElement()->Clear();
for (NamespaceMap::iterator it = bld->namespaces.begin(); it != bld->namespaces.end(); ++it)
{
delete it->second;
bld->namespaces.erase(it);
}
}
bool InfoPane::RemoveNonLogger(wxWindow* p)
{
for(int i = 0; i < num_pages; ++i)
{
if(page[i].window == p)
{
if(page[i].islogger)
{
cbThrow(_T("Bad API usage. Shame on you."));
}
RemovePage(GetPageIndex(page[i].window));
page[i] = Page();
return true;
}
}
return false;
}
ScriptingManager::ScriptingManager()
: m_AttachedToMainWindow(false),
m_MenuItemsManager(false) // not auto-clear
{
//ctor
// initialize but don't load the IO lib
SquirrelVM::Init((SquirrelInitFlags)(sqifAll & ~sqifIO));
if (!SquirrelVM::GetVMPtr())
cbThrow(_T("Can't create scripting engine!"));
sq_setprintfunc(SquirrelVM::GetVMPtr(), ScriptsPrintFunc);
sqstd_register_stringlib(SquirrelVM::GetVMPtr());
RefreshTrusts();
// register types
ScriptBindings::RegisterBindings();
}
void UsrGlblMgrEditDialog::OnFS(wxCommandEvent& event)
{
wxTextCtrl* c = nullptr;
int id = event.GetId();
if (id == XRCID("fs1"))
c = m_Base;
else if (id == XRCID("fs2"))
c = m_Include;
else if (id == XRCID("fs3"))
c = m_Lib;
else if (id == XRCID("fs4"))
c = m_Obj;
else if (id == XRCID("fs5"))
c = m_Bin;
else
cbThrow(_T("Encountered invalid button ID"));
wxString path = ChooseDirectory(this, _("Choose a location"), c->GetValue());
if (!path.IsEmpty())
c->SetValue(path);
}
AnnoyingDialog::AnnoyingDialog(const wxString& caption, const wxString& message, const wxArtID icon,
dStyle style, int defaultReturn, bool /*separate*/,
const wxString& b1, const wxString& b2, const wxString& b3)
: wxScrollingDialog(NULL, -1, caption, wxDefaultPosition, wxDefaultSize, wxCAPTION | wxSTAY_ON_TOP),
cb(0),
dontAnnoy(false),
defRet(defaultReturn)
{
// Em::Blocks needs wxWidgets 2.8
CompileTimeAssertion<wxMinimumVersion<2,8>::eval>::Assert();
ConfigManagerContainer::StringSet disabled = Manager::Get()->GetConfigManager(_T("an_dlg"))->ReadSSet(_T("/disabled"));
if(disabled.find(caption) != disabled.end())
{
dontAnnoy = true;
return;
}
wxBoxSizer *outerSizer = new wxBoxSizer( wxVERTICAL );
wxFlexGridSizer *mainArea = new wxFlexGridSizer(2, 0, 0);
wxStaticBitmap *bitmap = new wxStaticBitmap(this, -1, wxArtProvider::GetBitmap(icon, wxART_MESSAGE_BOX), wxDefaultPosition);
mainArea->Add(bitmap, 0, wxALL, 5);
wxStaticText *txt = new wxStaticText(this, -1, message, wxDefaultPosition, wxDefaultSize, 0);
mainArea->Add( txt, 0, wxALIGN_CENTER|wxALL, 5 );
mainArea->Add( 1, 1, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5 );
int numButtons = 0;
int id1 = -1;
int id2 = -1;
int id3 = -1;
wxString bTxt1;
wxString bTxt2;
wxString bTxt3;
if(style == OK || style == ONE_BUTTON)
{
numButtons = 1;
id1 = (style == OK ? wxID_OK : 1);
bTxt1 = b1.IsEmpty() ? wxString(_("&OK")) : b1;
}
else if(style == YES_NO || style == OK_CANCEL || style == TWO_BUTTONS)
{
numButtons = 2;
id1 = (style == YES_NO ? wxID_YES : (style == OK_CANCEL ? wxID_OK : 1));
id2 = (style == YES_NO ? wxID_NO : (style == OK_CANCEL ? wxID_CANCEL : 2));
bTxt1 = b1.IsEmpty() ? (style == YES_NO ? wxString(_("&Yes")) : wxString(_("&OK"))) : b1;
bTxt2 = b2.IsEmpty() ? (style == YES_NO ? wxString(_("&No")) : wxString(_("&Cancel"))) : b2;
}
else if(style == YES_NO_CANCEL || style == THREE_BUTTONS)
{
numButtons = 3;
id1 = (style == YES_NO_CANCEL ? wxID_YES : 1);
id2 = (style == YES_NO_CANCEL ? wxID_NO : 2);
id3 = (style == YES_NO_CANCEL ? wxID_CANCEL : 3);
bTxt1 = b1.IsEmpty() ? wxString(_("&Yes")) : b1;
bTxt2 = b2.IsEmpty() ? wxString(_("&No")) : b2;
bTxt3 = b3.IsEmpty() ? wxString(_("&Cancel")) : b3;
}
else
cbThrow(wxString(_T("Fatal error:\nUndefined style in dialog ")) << caption);
wxSizer* buttonSizer = 0;
if (style < ONE_BUTTON) // standard buttons? use wxStdDialogButtonSizer
{
wxStdDialogButtonSizer *buttonArea = new wxStdDialogButtonSizer();
wxButton *but1 = new wxButton(this, id1, bTxt1, wxDefaultPosition, wxDefaultSize, 0);
but1->SetDefault();
buttonArea->AddButton(but1);
if(numButtons > 1)
{
wxButton *but2 = new wxButton(this, id2, bTxt2, wxDefaultPosition, wxDefaultSize, 0);
but2->SetDefault();
buttonArea->AddButton(but2);
}
if(numButtons > 2)
{
wxButton *but3 = new wxButton(this, id3, bTxt3, wxDefaultPosition, wxDefaultSize, 0);
but3->SetDefault();
buttonArea->AddButton(but3);
}
buttonArea->Realize();
buttonSizer = buttonArea;
}
else
{
// wxStdDialogButtonSizer accepts only standard IDs for its buttons, so we can't use
// it with custom buttons
buttonSizer = new wxBoxSizer(wxHORIZONTAL);
wxButton *but1 = new wxButton(this, id1, bTxt1, wxDefaultPosition, wxDefaultSize, 0);
but1->SetDefault();
buttonSizer->Add(but1, 0, wxRIGHT, 5);
if(numButtons > 1)
{
wxButton *but2 = new wxButton(this, id2, bTxt2, wxDefaultPosition, wxDefaultSize, 0);
but2->SetDefault();
buttonSizer->Add(but2, 0, wxRIGHT, 5);
}
if(numButtons > 2)
{
wxButton *but3 = new wxButton(this, id3, bTxt3, wxDefaultPosition, wxDefaultSize, 0);
but3->SetDefault();
buttonSizer->Add(but3, 0, wxRIGHT, 5);
}
}
outerSizer->Add( mainArea, 0, wxALIGN_CENTER|wxALL, 5);
outerSizer->Add( buttonSizer, 0, wxALIGN_CENTER);
cb = new wxCheckBox(this, -1, _("Don't annoy me again!"), wxDefaultPosition, wxDefaultSize, 0);
outerSizer->Add(cb, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
SetSizer( outerSizer );
outerSizer->SetSizeHints(this);
Centre();
}
/// This is to be used *only* for files not belonging to a project!!!
wxArrayString DirectCommands::GetCompileSingleFileCommand(const wxString& filename) const
{
wxArrayString ret;
// lookup file's type
FileType ft = FileTypeOf(filename);
// is it compilable?
if (ft != ftSource)
return ret;
wxFileName fname(filename);
fname.SetExt(m_pCompiler->GetSwitches().objectExtension);
wxString o_filename = fname.GetFullPath();
wxString srcExt = fname.GetExt();
fname.SetExt(FileFilters::EXECUTABLE_EXT);
wxString exe_filename = fname.GetFullPath();
wxString s_filename = filename;
QuoteStringIfNeeded(s_filename);
QuoteStringIfNeeded(o_filename);
Compiler* compiler = CompilerFactory::GetDefaultCompiler();
if (!compiler)
return ret;
// please leave this check here for convenience: single file compilation is "special"
if (!m_pGenerator) cbThrow(_T("Command generator not initialised through ctor!"));
wxString compilerCmd = compiler->GetCommand(ctCompileObjectCmd, srcExt);
m_pGenerator->GenerateCommandLine(compilerCmd,
0,
0,
s_filename,
o_filename,
o_filename,
wxEmptyString);
wxString linkerCmd = compiler->GetCommand(ctLinkConsoleExeCmd, fname.GetExt());
m_pGenerator->GenerateCommandLine(linkerCmd,
0,
0,
wxEmptyString,
o_filename,
o_filename,
wxEmptyString);
if (!compilerCmd.IsEmpty())
{
switch (m_pCompiler->GetSwitches().logging)
{
case clogFull:
ret.Add(COMPILER_SIMPLE_LOG + compilerCmd);
break;
case clogSimple:
ret.Add(COMPILER_SIMPLE_LOG + _("Compiling: ") + filename);
break;
case clogNone: // fall-through
default:
break;
}
AddCommandsToArray(compilerCmd, ret);
}
else
ret.Add(COMPILER_SIMPLE_LOG + _("Skipping file (no compiler program set): ") + filename);
if (!linkerCmd.IsEmpty())
{
switch (m_pCompiler->GetSwitches().logging)
{
case clogFull:
ret.Add(COMPILER_SIMPLE_LOG + linkerCmd);
break;
case clogSimple: // fall-through
case clogNone: // fall-through
default: // linker always simple log (if not full)
ret.Add(COMPILER_SIMPLE_LOG + _("Linking console executable: ") + exe_filename);
break;
}
AddCommandsToArray(linkerCmd, ret, true);
}
else
ret.Add(COMPILER_SIMPLE_LOG + _("Skipping linking (no linker program set): ") + exe_filename);
return ret;
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
{
if (!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if (!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if (!referenceWindow) // no application window available, so this is as good as we can get
referenceWindow = w;
int the_mode;
if (mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
wxRect monitorRect;
if (wxDisplay::GetCount() > 0)
{
int displayIdx = wxDisplay::GetFromWindow(referenceWindow);
if (displayIdx == wxNOT_FOUND)
displayIdx = 0;
wxDisplay display(displayIdx);
monitorRect = display.GetClientArea();
// This is needed because on Linux the client area returned for the first monitor in a twin
// monitor setup with nVidia card is spanning the two monitors.
// The intersection function will return just the client for the specified monitor.
monitorRect = display.GetGeometry().Intersect(monitorRect);
}
else
{
int width, height;
wxDisplaySize(&width, &height);
monitorRect = wxRect(0, 0, width, height);
}
wxRect windowRect = w->GetRect();
switch(the_mode)
{
case pdlCentre:
{
windowRect.x = monitorRect.x + (monitorRect.width - windowRect.width)/2;
windowRect.y = monitorRect.y + (monitorRect.height - windowRect.height)/2;
}
break;
case pdlHead:
{
windowRect.x = monitorRect.x + (monitorRect.width - windowRect.width)/2;
windowRect.y = monitorRect.y + (monitorRect.height - windowRect.height)/3;
}
break;
case pdlConstrain:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
if (windowRect.width > monitorRect.width) // cannot place without clipping, so centre it
{
x1 = monitorRect.x + (monitorRect.width - windowRect.width)/2;
x2 = x1 + windowRect.width;
}
else
{
x2 = std::min(monitorRect.GetRight(), windowRect.GetRight());
x1 = std::max(x2 - windowRect.width, monitorRect.x);
x2 = x1 + windowRect.width;
}
if (windowRect.height > monitorRect.height) // cannot place without clipping, so centre it
{
y1 = monitorRect.y + (monitorRect.height - windowRect.height)/2;
y2 = y1 + windowRect.height;
}
else
{
y2 = std::min(monitorRect.GetBottom(), windowRect.GetBottom());
y1 = std::max(y2 - windowRect.height, monitorRect.y);
y2 = y1 + windowRect.height;
}
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
case pdlClip:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, monitorRect.x);
x2 = std::min(x2, monitorRect.GetRight());
y1 = std::max(y1, monitorRect.y);
y2 = std::min(y2, monitorRect.GetBottom());
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
}
w->SetSize(windowRect.x, windowRect.y, windowRect.width, windowRect.height, wxSIZE_ALLOW_MINUS_ONE);
}
void CfgMgrBldr::SwitchTo(const wxString& fileName)
{
doc = new TiXmlDocument();
if (!TinyXML::LoadDocument(fileName, doc))
{
doc->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
doc->InsertEndChild(TiXmlElement("CodeBlocksConfig"));
doc->FirstChildElement("CodeBlocksConfig")->SetAttribute("version", CfgMgrConsts::version);
}
if (doc->ErrorId())
cbThrow(wxString::Format(_T("TinyXML error: %s\nIn file: %s\nAt row %d, column: %d."), cbC2U(doc->ErrorDesc()).c_str(), fileName.c_str(), doc->ErrorRow(), doc->ErrorCol()));
TiXmlElement* docroot = doc->FirstChildElement("CodeBlocksConfig");
if (doc->ErrorId())
cbThrow(wxString::Format(_T("TinyXML error: %s\nIn file: %s\nAt row %d, column: %d."), cbC2U(doc->ErrorDesc()).c_str(), fileName.c_str(), doc->ErrorRow(), doc->ErrorCol()));
const char *vers = docroot->Attribute("version");
if (!vers || atoi(vers) != 1)
cbMessageBox(_("ConfigManager encountered an unknown config file version. Continuing happily."), _("Warning"), wxICON_WARNING);
doc->ClearError();
wxString info;
#ifndef __GNUC__
info.Printf(_T( " application info:\n"
"\t svn_revision:\t%u\n"
"\t build_date:\t%s, %s "), ConfigManager::GetRevisionNumber(), wxT(__DATE__), wxT(__TIME__));
#else
info.Printf(_T( " application info:\n"
"\t svn_revision:\t%u\n"
"\t build_date:\t%s, %s\n"
"\t gcc_version:\t%d.%d.%d "), ConfigManager::GetRevisionNumber(), wxT(__DATE__), wxT(__TIME__),
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
#endif
if (platform::windows)
info.append(_T("\n\t Windows "));
if (platform::linux)
info.append(_T("\n\t Linux "));
if (platform::macosx)
info.append(_T("\n\t Mac OS X "));
if (platform::unix)
info.append(_T("\n\t Unix "));
info.append(platform::unicode ? _T("Unicode ") : _T("ANSI "));
TiXmlComment c;
c.SetValue((const char*) info.mb_str());
TiXmlNode *firstchild = docroot->FirstChild();
if (firstchild && firstchild->ToComment())
{
docroot->RemoveChild(firstchild);
firstchild = docroot->FirstChild();
}
if (firstchild)
docroot->InsertBeforeChild(firstchild, c);
else
docroot->InsertEndChild(c);
}
// Script binding support
void cbStyledTextCtrl::operator=(const cbStyledTextCtrl& /*rhs*/)
{
cbThrow(_T("Can't assign an cbStyledTextCtrl* !!!"));
}
void PlaceWindow(wxTopLevelWindow *w, cbPlaceDialogMode mode, bool enforce)
{
HMONITOR hMonitor;
MONITORINFO mi;
RECT r;
int the_mode;
if(!w)
cbThrow(_T("Passed NULL pointer to PlaceWindow."));
wxWindow* referenceWindow = Manager::Get()->GetAppWindow();
if(!referenceWindow) // no application window available, so this is as good as we can get
referenceWindow = w;
wxRect windowRect = w->GetRect();
ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));
if(!enforce && cfg->ReadBool(_T("/dialog_placement/do_place")) == false)
return;
if(mode == pdlBest)
the_mode = cfg->ReadInt(_T("/dialog_placement/dialog_position"), (int) pdlCentre);
else
the_mode = (int) mode;
static MonitorFromWindow_t MonitorFromWindowProc = (MonitorFromWindow_t) GetProcAddress(GetModuleHandle(_T("user32.dll")), "MonitorFromWindow");
static GetMonitorInfo_t GetMonitorInfoProc = (GetMonitorInfo_t) GetProcAddress(GetModuleHandle(_T("user32.dll")), "GetMonitorInfoA");
int monitorWidth;
int monitorHeight;
if(GetMonitorInfoProc)
{
hMonitor = MonitorFromWindowProc((HWND) referenceWindow->GetHandle(), MONITOR_DEFAULTTONEAREST);
mi.cbSize = sizeof(mi);
GetMonitorInfoProc(hMonitor, &mi);
r = mi.rcWork;
monitorWidth = r.right - r.left;
monitorHeight = r.bottom - r. top;
}
else // Win95, NT4: support only single monitor
{
wxDisplaySize(&monitorWidth, &monitorHeight);
r.left = r.top = 0;
}
switch(the_mode)
{
case pdlCentre:
{
windowRect.x = r.left + (monitorWidth - windowRect.width)/2;
windowRect.y = r.top + (monitorHeight - windowRect.height)/2;
}
break;
case pdlHead:
{
windowRect.x = r.left + (monitorWidth - windowRect.width)/2;
windowRect.y = r.top + (monitorHeight - windowRect.height)/3;
}
break;
case pdlConstrain:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
if(windowRect.width > monitorWidth) // cannot place without clipping, so centre it
{
x1 = r.left + (monitorWidth - windowRect.width)/2;
x2 = x1 + windowRect.width;
}
else
{
x2 = std::min((int) r.right, windowRect.GetRight());
x1 = std::max(x2 - windowRect.width, (int) r.left);
x2 = x1 + windowRect.width;
}
if(windowRect.height > monitorHeight) // cannot place without clipping, so centre it
{
y1 = r.top + (monitorHeight - windowRect.height)/2;
y2 = y1 + windowRect.height;
}
else
{
y2 = std::min((int) r.bottom, windowRect.GetBottom());
y1 = std::max(y2 - windowRect.height, (int) r.top);
y2 = y1 + windowRect.height;
}
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
case pdlClip:
{
int x1 = windowRect.x;
int x2 = windowRect.x + windowRect.width;
int y1 = windowRect.y;
int y2 = windowRect.y + windowRect.height;
x1 = std::max(x1, (int) r.left);
x2 = std::min(x2, (int) r.right);
y1 = std::max(y1, (int) r.top);
y2 = std::min(y2, (int) r.bottom);
windowRect = wxRect(x1, y1, x2-x1, y2-y1);
}
break;
}
w->SetSize(windowRect.x, windowRect.y, windowRect.width, windowRect.height, wxSIZE_ALLOW_MINUS_ONE);
}
wxArrayString DirectCommands::GetTargetLinkCommands(ProjectBuildTarget* target, bool force)
{
wxArrayString ret;
wxString output = target->GetOutputFilename();
Manager::Get()->GetMacrosManager()->ReplaceMacros(output, target);
wxFileName out = UnixFilename(output);
wxString linkfiles;
wxString FlatLinkFiles;
wxString resfiles;
bool IsOpenWatcom = target->GetCompilerID().IsSameAs(_T("ow"));
time_t outputtime;
depsTimeStamp(output.mb_str(), &outputtime);
if (!outputtime)
force = true;
if (AreExternalDepsOutdated(out.GetFullPath(), target->GetAdditionalOutputFiles(), target->GetExternalDeps()))
force = true;
Compiler* compiler = target ? CompilerFactory::GetCompiler(target->GetCompilerID()) : m_pCompiler;
wxString prependHack; // part of the following hack
if (target->GetTargetType() == ttStaticLib)
{
// QUICK HACK: some linkers (e.g. bcc, dmc) require a - or + in front of
// object files for static library. What we 'll do here until we redesign
// the thing, is to accept this symbol as part of the $link_objects macro
// like this:
// $+link_objects
// $-link_objects
// $-+link_objects
// $+-link_objects
//
// So, we first scan the command for this special case and, if found,
// set a flag so that the linkfiles array is filled with the correct options
wxString compilerCmd = compiler->GetCommand(ctLinkStaticCmd);
wxRegEx re(_T("\\$([-+]+)link_objects"));
if (re.Matches(compilerCmd))
prependHack = re.GetMatch(compilerCmd, 1);
}
// get all the linkable objects for the target
MyFilesArray files = GetProjectFilesSortedByWeight(target, false, true);
wxString allfile;
if (files.GetCount() == 0)
{
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Linking stage skipped (build target has no object files to link)"));
return ret;
}
if (IsOpenWatcom && target->GetTargetType() != ttStaticLib)
linkfiles << _T("file ");
for (unsigned int i = 0; i < files.GetCount(); ++i)
{
ProjectFile* pf = files[i];
// we have to test again for each file if it is to be compiled
// and we can't check the file for existence because we 're still
// generating the command lines that will create the files...
wxString macro = _T("$compiler");
if(m_pCompiler->GetParentID().Matches(_T("lcy")))
{
if(pf->file.GetExt().Lower().IsSameAs(FileFilters::LD_EXT))
continue;
}
// allfile = allfile + _T(" ") + pf->GetObjName().BeforeLast(_T('.'))+_T('.')+pf->file.GetExt();
compiler->GenerateCommandLine(macro, target, pf, wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
if (macro.IsEmpty())
continue;
const pfDetails& pfd = pf->GetFileDetails(target);
wxString Object = (target->GetUseFlatObjects())?pfd.object_file_flat:pfd.object_file;
if (FileTypeOf(pf->relativeFilename) == ftResource)
{
// -----------------------------------------
// Following lines have been modified for OpenWatcom
if (IsOpenWatcom)
resfiles << _T("option resource=") << Object << _T(" ");
else
resfiles << Object << _T(" ");
// ------------------------------------------
}
else
{
// -----------------------------------------
// Following lines have been modified for OpenWatcom
if (IsOpenWatcom && target->GetTargetType() != ttStaticLib)
{
linkfiles << prependHack << Object << _T(","); // see QUICK HACK above (prependHack)
FlatLinkFiles << prependHack << pfd.object_file_flat << _T(","); // see QUICK HACK above (prependHack)
}
else
{
linkfiles << prependHack << Object << _T(" "); // see QUICK HACK above (prependHack)
FlatLinkFiles << prependHack << pfd.object_file_flat << _T(" "); // see QUICK HACK above (prependHack)
}
// -----------------------------------------
}
// timestamp check
if (!force)
{
time_t objtime;
depsTimeStamp(pfd.object_file_native.mb_str(), &objtime);
if (objtime > outputtime)
force = true;
}
// Why was this here?
// if(m_doYield)
// Manager::Yield();
}
if (IsOpenWatcom)
{
linkfiles.Trim();
if (linkfiles.Right(1).IsSameAs(_T(",")))
linkfiles = linkfiles.BeforeLast(_T(','));
}
if (!force)
return ret;
if(target->GetCompilerID().Lower().Matches(_T("dsp"))) /// 2012-8-29 lcy
{
// FlatLinkFiles.Replace(_T(".obj"),_T(".cln"));
FlatLinkFiles.Replace(_T("\\"),_T(" "));
// linkfiles.Replace(_T(".obj"),_T(".cln"));
linkfiles.Replace(_T("\\"),_T(" "));
}
// create output dir
out.MakeAbsolute(m_pProject->GetBasePath());
wxString dstname = out.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
Manager::Get()->GetMacrosManager()->ReplaceMacros(dstname, target);
if (!dstname.IsEmpty() && !CreateDirRecursively(dstname, 0755))
{
cbMessageBox(_("Can't create output directory ") + dstname);
}
// add actual link command
wxString kind_of_output;
CommandType ct = ctCount; // get rid of compiler warning
switch (target->GetTargetType())
{
case ttConsoleOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _("console executable");
break;
case ttExecutable:
ct = ctLinkExeCmd;
kind_of_output = _("executable");
break;
case ttDynamicLib:
ct = ctLinkDynamicCmd;
kind_of_output = _("dynamic library");
break;
case ttStaticLib:
ct = ctLinkStaticCmd;
kind_of_output = _("static library");
break;
case ttNative:
ct = ctLinkNativeCmd;
kind_of_output = _("native");
break;
case ttCommandsOnly:
// add target post-build commands
ret.Clear();
AppendArray(GetPostBuildCommands(target), ret);
return ret;
break;
default:
wxString ex;
ex.Printf(_T("Encountered invalid TargetType (value = %d)"), target->GetTargetType());
cbThrow(ex);
break;
}
wxString compilerCmd = compiler->GetCommand(ct);
compiler->GenerateCommandLine(compilerCmd,
target,
0,
_T(""),
linkfiles,
FlatLinkFiles,
resfiles);
if(target->GetCompilerID().Lower().Matches(_T("dsp"))) /// 2012-8-29 lcy
{
compilerCmd.Replace(_("#allfile"),allfile);
}
if (!compilerCmd.IsEmpty())
{
switch (compiler->GetSwitches().logging)
{
case clogFull:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + compilerCmd);
break;
default: // linker always simple log (if not full)
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Linking ") + kind_of_output + _T(": ") + output);
break;
}
// for an explanation of the following, see GetTargetCompileCommands()
if (target && ret.GetCount() != 0)
ret.Add(wxString(COMPILER_TARGET_CHANGE) + target->GetTitle());
// the 'true' will make sure all commands will be prepended by
// COMPILER_WAIT signal
AddCommandsToArray(compilerCmd, ret, true, true);
}
else
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Skipping linking (no linker program set): ") + output);
return ret;
}
ProgressDialog& operator=(const ProgressDialog&)
{
cbThrow(_T("ProgressDialog copy constructor should never be called!"));
}
void AnnoyingDialog::Init(const wxString &caption, const wxString &id, const wxString& message, const wxArtID icon,
dStyle style, const wxString& b1, const wxString& b2, const wxString& b3)
{
m_CheckBox = nullptr;
m_DontAnnoy = false;
m_Id = id;
static_assert(wxMinimumVersion<2,8,12>::eval, "wxWidgets 2.8.12 is required");
ConfigManagerContainer::StringSet disabled;
ConfigManager* cfg = Manager::Get()->GetConfigManager(wxT("an_dlg"));
if (cfg->Exists(wxT("/disabled_ret")))
{
// new config style, includes return code in format:
// "id:dReturnType"
// example:
// "Question XYZ?:4"
disabled = cfg->ReadSSet(wxT("/disabled_ret"));
}
else
{
// if the new config key does not exist, read from the old one
// old keys are in format:
// "id"
disabled = cfg->ReadSSet(wxT("/disabled"));
// and copy it to the new one
cfg->Write(wxT("/disabled_ret"), disabled);
// we do not do an in place upgrade of the format to maintain
// compatibility with previous versions
}
ConfigManagerContainer::StringSet::const_iterator it = disabled.lower_bound(m_Id);
if (it != disabled.end())
{
if (*it == m_Id)
{
// upgrade old settings
m_DontAnnoy = true;
if (m_DefRet == rtSAVE_CHOICE)
m_DefRet = rtYES; // default value
disabled.erase(it);
disabled.insert(m_Id + F(wxT(":%d"), m_DefRet));
// save updated format
cfg->Write(wxT("/disabled_ret"), disabled);
return;
}
else if (it->BeforeLast(wxT(':')) == m_Id)
{
m_DontAnnoy = true;
// read the saved choice and store it for ShowModal() to use
long ret = rtSAVE_CHOICE;
if (it->AfterLast(wxT(':')).ToLong(&ret) && ret != rtSAVE_CHOICE)
{
Manager::Get()->GetLogManager()->Log(*it);
m_DefRet = (dReturnType)ret;
}
else if (m_DefRet == rtSAVE_CHOICE)
m_DefRet = rtYES; // default value
return;
}
}
wxBoxSizer *outerSizer = new wxBoxSizer( wxVERTICAL );
wxFlexGridSizer *mainArea = new wxFlexGridSizer(2, 0, 0);
wxStaticBitmap *bitmap = new wxStaticBitmap(this, -1, wxArtProvider::GetBitmap(icon, wxART_MESSAGE_BOX), wxDefaultPosition);
mainArea->Add(bitmap, 0, wxALL, 5);
wxStaticText *txt = new wxStaticText(this, -1, message, wxDefaultPosition, wxDefaultSize, 0);
mainArea->Add( txt, 0, wxALIGN_CENTER|wxALL, 5 );
mainArea->Add( 1, 1, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5 );
int numButtons = 0;
dReturnType id1 = rtINVALID;
dReturnType id2 = rtINVALID;
dReturnType id3 = rtINVALID;
wxString bTxt1;
wxString bTxt2;
wxString bTxt3;
if(style == OK || style == ONE_BUTTON)
{
numButtons = 1;
// only one choice, so set m_DefRet
m_DefRet = (style == OK ? rtOK : rtONE);
id1 = m_DefRet;
bTxt1 = b1.IsEmpty() ? wxString(_("&OK")) : b1;
}
else if(style == YES_NO || style == OK_CANCEL || style == TWO_BUTTONS)
{
numButtons = 2;
id1 = (style == YES_NO ? rtYES : (style == OK_CANCEL ? rtOK : rtONE));
id2 = (style == YES_NO ? rtNO : (style == OK_CANCEL ? rtCANCEL : rtTWO));
bTxt1 = b1.IsEmpty() ? (style == YES_NO ? wxString(_("&Yes")) : wxString(_("&OK"))) : b1;
bTxt2 = b2.IsEmpty() ? (style == YES_NO ? wxString(_("&No")) : wxString(_("&Cancel"))) : b2;
// this is the default, so apply correct return type (if it was not set)
if (m_DefRet == rtYES)
m_DefRet = id1;
}
else if(style == YES_NO_CANCEL || style == THREE_BUTTONS)
{
numButtons = 3;
id1 = (style == YES_NO_CANCEL ? rtYES : rtONE);
id2 = (style == YES_NO_CANCEL ? rtNO : rtTWO);
id3 = (style == YES_NO_CANCEL ? rtCANCEL : rtTHREE);
bTxt1 = b1.IsEmpty() ? wxString(_("&Yes")) : b1;
bTxt2 = b2.IsEmpty() ? wxString(_("&No")) : b2;
bTxt3 = b3.IsEmpty() ? wxString(_("&Cancel")) : b3;
}
else
cbThrow(wxString(_T("Fatal error:\nUndefined style in dialog ")) << caption);
wxSizer* buttonSizer = nullptr;
if (style < ONE_BUTTON) // standard buttons? use wxStdDialogButtonSizer
{
wxStdDialogButtonSizer *buttonArea = new wxStdDialogButtonSizer();
wxButton* but1 = new wxButton(this, id1 == rtYES ? wxID_YES : wxID_OK, bTxt1, wxDefaultPosition, wxDefaultSize, 0);
but1->SetDefault();
buttonArea->AddButton(but1);
if(numButtons > 1)
{
wxButton* but2 = new wxButton(this, id2 == rtNO ? wxID_NO : wxID_CANCEL, bTxt2, wxDefaultPosition, wxDefaultSize, 0);
if (id2 == m_DefRet)
but2->SetDefault();
buttonArea->AddButton(but2);
}
if(numButtons > 2)
{
wxButton* but3 = new wxButton(this, wxID_CANCEL, bTxt3, wxDefaultPosition, wxDefaultSize, 0);
if (id3 == m_DefRet)
but3->SetDefault();
buttonArea->AddButton(but3);
}
buttonArea->Realize();
buttonSizer = buttonArea;
}
else
{
// wxStdDialogButtonSizer accepts only standard IDs for its buttons, so we can't use
// it with custom buttons
buttonSizer = new wxBoxSizer(wxHORIZONTAL);
wxButton *but1 = new wxButton(this, id1, bTxt1, wxDefaultPosition, wxDefaultSize, 0);
but1->SetDefault();
buttonSizer->Add(but1, 0, wxRIGHT, 5);
if(numButtons > 1)
{
wxButton *but2 = new wxButton(this, id2, bTxt2, wxDefaultPosition, wxDefaultSize, 0);
if (id2 == m_DefRet)
but2->SetDefault();
buttonSizer->Add(but2, 0, wxRIGHT, 5);
}
if(numButtons > 2)
{
wxButton *but3 = new wxButton(this, id3, bTxt3, wxDefaultPosition, wxDefaultSize, 0);
if (id3 == m_DefRet)
but3->SetDefault();
buttonSizer->Add(but3, 0, wxRIGHT, 5);
}
}
outerSizer->Add( mainArea, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
outerSizer->Add( buttonSizer, 0, wxALIGN_CENTER_HORIZONTAL);
m_CheckBox = new wxCheckBox(this, wxID_ANY, _("Don't annoy me again!"), wxDefaultPosition, wxDefaultSize, 0);
outerSizer->Add(m_CheckBox, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
SetSizer( outerSizer );
outerSizer->SetSizeHints(this);
Centre();
}
wxArrayString DirectCommands::GetTargetLinkCommands(ProjectBuildTarget* target, bool force) const
{
wxArrayString ret;
wxString output = target->GetOutputFilename();
Manager::Get()->GetMacrosManager()->ReplaceMacros(output, target);
wxFileName out = UnixFilename(output);
wxString linkfiles;
wxString FlatLinkFiles;
wxString resfiles;
bool IsOpenWatcom = target->GetCompilerID().IsSameAs(_T("ow"));
time_t outputtime;
depsTimeStamp(output.mb_str(), &outputtime);
if (!outputtime)
force = true;
wxArrayString fileMissing;
if ( AreExternalDepsOutdated(target, out.GetFullPath(), &fileMissing) )
force = true;
if (!fileMissing.IsEmpty())
{
wxString warn;
#ifdef NO_TRANSLATION
warn.Printf(wxT("WARNING: Target '%s': Unable to resolve %lu external dependenc%s:"),
target->GetFullTitle().wx_str(), static_cast<unsigned long>(fileMissing.Count()), wxString(fileMissing.Count() == 1 ? wxT("y") : wxT("ies")).wx_str());
#else
warn.Printf(_("WARNING: Target '%s': Unable to resolve %lu external dependency/ies:"),
target->GetFullTitle().wx_str(), static_cast<unsigned long>(fileMissing.Count()));
#endif // NO_TRANSLATION
ret.Add(COMPILER_WARNING_LOG + warn);
for (size_t i = 0; i < fileMissing.Count(); ++i)
ret.Add(COMPILER_NOTE_LOG + wxString(wxT(' '), 8) + fileMissing[i]);
}
Compiler* compiler = target ? CompilerFactory::GetCompiler(target->GetCompilerID()) : m_pCompiler;
wxString prependHack; // part of the following hack
if (target->GetTargetType() == ttStaticLib)
{
// QUICK HACK: some linkers (e.g. bcc, dmc) require a - or + in front of
// object files for static library. What we 'll do here until we redesign
// the thing, is to accept this symbol as part of the $link_objects macro
// like this:
// $+link_objects
// $-link_objects
// $-+link_objects
// $+-link_objects
//
// So, we first scan the command for this special case and, if found,
// set a flag so that the linkfiles array is filled with the correct options
wxString compilerCmd = compiler ? compiler->GetCommand(ctLinkStaticCmd) : wxString(wxEmptyString);
wxRegEx re(_T("\\$([-+]+)link_objects"));
if (re.Matches(compilerCmd))
prependHack = re.GetMatch(compilerCmd, 1);
}
// get all the linkable objects for the target
MyFilesArray files = GetProjectFilesSortedByWeight(target, false, true);
if (files.GetCount() == 0)
{
if (target->GetTargetType() != ttCommandsOnly)
ret.Add(COMPILER_SIMPLE_LOG + _("Linking stage skipped (build target has no object files to link)"));
return ret;
}
if (IsOpenWatcom && target->GetTargetType() != ttStaticLib)
linkfiles << _T("file ");
bool subseq(false);
for (unsigned int i = 0; i < files.GetCount(); ++i)
{
ProjectFile* pf = files[i];
// we have to test again for each file if it is to be compiled
// and we can't check the file for existence because we 're still
// generating the command lines that will create the files...
wxString macro = _T("$compiler");
m_pGenerator->GenerateCommandLine(macro, target, pf, wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
if (macro.IsEmpty())
continue;
const pfDetails& pfd = pf->GetFileDetails(target);
wxString Object = (compiler->GetSwitches().UseFlatObjects) ? pfd.object_file_flat
: pfd.object_file;
if (FileTypeOf(pf->relativeFilename) == ftResource)
{
if (subseq)
resfiles << _T(" ");
// -----------------------------------------
// Following lines have been modified for OpenWatcom
if (IsOpenWatcom)
resfiles << _T("option resource=") << Object;
else
resfiles << Object;
// ------------------------------------------
}
else
{
// -----------------------------------------
// Following lines have been modified for OpenWatcom
if (IsOpenWatcom && target->GetTargetType() == ttStaticLib)
{
if (subseq)
{
linkfiles << _T(" ");
FlatLinkFiles << _T(" ");
}
linkfiles << prependHack << Object; // see QUICK HACK above (prependHack)
FlatLinkFiles << prependHack << pfd.object_file_flat; // see QUICK HACK above (prependHack)
}
else
{
if (subseq)
{
linkfiles << compiler->GetSwitches().objectSeparator;
FlatLinkFiles << compiler->GetSwitches().objectSeparator;
}
linkfiles << prependHack << Object; // see QUICK HACK above (prependHack)
FlatLinkFiles << prependHack << pfd.object_file_flat; // see QUICK HACK above (prependHack)
}
// -----------------------------------------
}
subseq = true;
// timestamp check
if (!force)
{
time_t objtime;
depsTimeStamp(pfd.object_file_native.mb_str(), &objtime);
// Honor compiler request to Use Flat Objects
// (Settings/compiler/otherSettings/advancedOptions/Others/UseFlatObjects)
if (compiler->GetSwitches().UseFlatObjects)
depsTimeStamp(pfd.object_file_flat.mb_str(), &objtime);
if (!objtime)
force = true;
if (objtime > outputtime)
force = true;
}
}
if (IsOpenWatcom)
{
linkfiles.Trim();
}
if (!force)
return ret;
// create output dir
out.MakeAbsolute(m_pProject->GetBasePath());
wxString dstname = out.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
Manager::Get()->GetMacrosManager()->ReplaceMacros(dstname, target);
if (!dstname.IsEmpty() && !CreateDirRecursively(dstname, 0755))
{
cbMessageBox(_("Can't create output directory ") + dstname);
}
// add actual link command
wxString kind_of_output;
CommandType ct = ctCount; // get rid of compiler warning
switch (target->GetTargetType())
{
case ttConsoleOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _("console executable");
break;
case ttExecutable:
ct = ctLinkExeCmd;
kind_of_output = _("executable");
break;
case ttDynamicLib:
ct = ctLinkDynamicCmd;
kind_of_output = _("dynamic library");
break;
case ttStaticLib:
ct = ctLinkStaticCmd;
kind_of_output = _("static library");
break;
case ttNative:
ct = ctLinkNativeCmd;
kind_of_output = _("native");
break;
case ttCommandsOnly:
// add target post-build commands
ret.Clear();
AppendArray(GetPostBuildCommands(target), ret);
return ret;
break;
default:
wxString ex;
ex.Printf(_T("Encountered invalid TargetType (value = %d)"), target->GetTargetType());
cbThrow(ex);
break;
}
wxString compilerCmd = compiler->GetCommand(ct);
m_pGenerator->GenerateCommandLine(compilerCmd,
target,
0,
_T(""),
linkfiles,
FlatLinkFiles,
resfiles);
if (!compilerCmd.IsEmpty())
{
switch (compiler->GetSwitches().logging)
{
case clogFull:
ret.Add(COMPILER_SIMPLE_LOG + compilerCmd);
break;
case clogSimple: // fall-through
case clogNone: // fall-through
default: // linker always simple log (if not full)
ret.Add(COMPILER_SIMPLE_LOG + _("Linking ") + kind_of_output + _T(": ") + output);
break;
}
// for an explanation of the following, see GetTargetCompileCommands()
if (target && ret.GetCount() != 0)
ret.Add(COMPILER_TARGET_CHANGE + target->GetTitle());
// the 'true' will make sure all commands will be prepended by
// COMPILER_WAIT signal
AddCommandsToArray(compilerCmd, ret, true, true);
}
else
ret.Add(COMPILER_SIMPLE_LOG + _("Skipping linking (no linker program set): ") + output);
return ret;
}
void Parser::OnAllThreadsDone(CodeBlocksEvent& event)
{
if (m_IgnoreThreadEvents || Manager::IsAppShuttingDown())
return;
if (event.GetId() != m_Pool.GetId())
{
CCLogger::Get()->DebugLog(_T("Why event.GetId() not equal m_Pool.GetId()?"));
return;
}
if (!m_TokensTree)
cbThrow(_T("m_TokensTree is a nullptr?!"));
if (!m_IsParsing)
{
CCLogger::Get()->DebugLog(_T("Why m_IsParsing is false?"));
return;
}
// Do next task
if ( !m_PoolTask.empty()
|| !m_BatchParseFiles.empty()
|| !m_PriorityHeaders.empty()
|| !m_PredefinedMacros.IsEmpty() )
{
m_BatchTimer.Start(10, wxTIMER_ONE_SHOT);
}
#if !CC_PARSER_PROFILE_TEST
// Reparse system priority headers
else if (!m_SystemPriorityHeaders.empty())
{
// 1. Remove all priority headers in token tree
for (StringList::iterator it = m_SystemPriorityHeaders.begin(); it != m_SystemPriorityHeaders.end(); ++it)
RemoveFile(*it);
// 2. Reparse system priority headers
AddBatchParse(m_SystemPriorityHeaders);
// 3. Clear
m_SystemPriorityHeaders.clear();
// 4. Begin batch parsing
m_BatchTimer.Start(10, wxTIMER_ONE_SHOT);
}
else if ( (m_ParsingType == ptCreateParser || m_ParsingType == ptAddFileToParser)
&& m_NeedMarkFileAsLocal
&& m_Project)
{
m_NeedMarkFileAsLocal = false;
MarkFileAsLocalThread* thread = new MarkFileAsLocalThread(*this, *m_Project);
m_Pool.AddTask(thread, true);
}
#endif
// Finish all task, then we need post a PARSER_END event
else
{
if (!m_Project)
m_NeedMarkFileAsLocal = false;
m_IgnoreThreadEvents = true;
m_NeedsReparse = false;
m_IsParsing = false;
m_IsBatchParseDone = true;
EndStopWatch();
wxString parseEndLog;
{
TRACK_THREAD_LOCKER(s_TokensTreeCritical);
wxCriticalSectionLocker locker(s_TokensTreeCritical);
THREAD_LOCKER_SUCCESS(s_TokensTreeCritical);
parseEndLog.Printf(_T("Project '%s' parsing stage done (%d total parsed files, ")
_T("%d tokens in %ld minute(s), %ld.%03ld seconds)."),
m_Project ? m_Project->GetTitle().wx_str() : _T("*NONE*"),
m_TokensTree ? m_TokensTree->m_FilesMap.size() : 0,
m_TokensTree ? m_TokensTree->realsize() : 0,
(m_LastStopWatchTime / 60000),
(m_LastStopWatchTime / 1000) % 60,
(m_LastStopWatchTime % 1000) );
}
ProcessParserEvent(m_ParsingType, idParserEnd, parseEndLog);
m_ParsingType = ptUndefined;
s_CurrentParser = nullptr;
}
}
