bool DirectCommands::IsObjectOutdated(ProjectBuildTarget* target, const pfDetails& pfd, wxString* errorStr)
{
// If the source file does not exist, then do not compile.
time_t timeSrc;
depsTimeStamp(pfd.source_file_absolute_native.mb_str(), &timeSrc);
if (!timeSrc)
{
if (errorStr)
*errorStr = _("WARNING: Can't read file's timestamp: ") + pfd.source_file_absolute_native;
if (wxFileExists(pfd.source_file_absolute_native))
{
return true;
}
return false;
}
// If the object file does not exist, then it must be built. In this case
// there is no need to scan the source file for headers.
time_t timeObj;
Compiler* compiler = target ? CompilerFactory::GetCompiler(target->GetCompilerID()) : m_pCompiler;
wxString ObjectAbs = (target->GetUseFlatObjects())?pfd.object_file_flat_absolute_native:pfd.object_file_absolute_native;
depsTimeStamp(ObjectAbs.mb_str(), &timeObj);
if(compiler->GetParentID().Matches(_T("lcy")))
{
wxString ramld = pfd.source_file_native;
if(ramld.Contains(_T(".ld")))
{
depsTimeStamp(ramld.mb_str(), &timeObj);
time_t ramldstamp = m_pCompilerPlugin->GetRamLDTimestamp();
if(timeObj > ramldstamp)
m_pCompilerPlugin->SetRamLDTimestamp(timeObj);
return (timeObj > ramldstamp );
}
}
if (!timeObj)
return true;
// If the source file is newer than the object file, then the object file
// must be built. In this case there is no need to scan the source file
// for headers.
if (timeSrc > timeObj)
return true;
// Scan the source file for headers. Result is NULL if the file does
// not exist. If one of the descendent header files is newer than the
// object file, then the object file must be built.
depsRef ref = depsScanForHeaders(pfd.source_file_absolute_native.mb_str());
if (ref)
{
time_t timeNewest;
(void) depsGetNewest(ref, &timeNewest);
return (timeNewest > timeObj);
}
// object file is up to date with source file
return false;
}
/** external deps are manualy set by the user
* e.g. a static library linked to the project is an external dep (if set as such by the user)
* so that a re-linking is forced if the static lib is updated
*/
bool DirectCommands::AreExternalDepsOutdated(const wxString& buildOutput, const wxString& additionalFiles, const wxString& externalDeps)
{
// array is separated by ;
wxArrayString deps = GetArrayFromString(externalDeps, _T(";"));
wxArrayString files = GetArrayFromString(additionalFiles, _T(";"));
for (size_t i = 0; i < deps.GetCount(); ++i)
{
if (deps[i].IsEmpty())
continue;
Manager::Get()->GetMacrosManager()->ReplaceMacros(deps[i]);
time_t timeSrc;
depsTimeStamp(deps[i].mb_str(), &timeSrc);
// if external dep doesn't exist, no need to relink
if (!timeSrc)
return false;
// let's check the additional output files
for (size_t x = 0; x < files.GetCount(); ++x)
{
if (files[x].IsEmpty())
continue;
Manager::Get()->GetMacrosManager()->ReplaceMacros(files[x]);
time_t addT;
depsTimeStamp(files[x].mb_str(), &addT);
// if additional file doesn't exist, we can skip it
if (!addT)
continue;
// if external dep is newer than additional file, relink
if (timeSrc > addT)
return true;
}
// if no output, probably a commands-only target; nothing to relink
if (buildOutput.IsEmpty())
return false;
// now check the target's output
// this is moved last because, for "commands only" targets,
// it would return before we had a chance to check the
// additional output files (above)
wxString output = buildOutput;
Manager::Get()->GetMacrosManager()->ReplaceMacros(output);
time_t timeExe;
depsTimeStamp(output.mb_str(), &timeExe);
// if build output doesn't exist, relink
if (!timeExe)
return true;
// if external dep is newer than build output, relink
if (timeSrc > timeExe)
return true;
}
return false; // no force relink
}
bool DirectCommands::IsObjectOutdated(ProjectBuildTarget* target, const pfDetails& pfd, wxString* errorStr) const
{
// If the source file does not exist, then do not compile.
time_t timeSrc;
depsTimeStamp(pfd.source_file_absolute_native.mb_str(), &timeSrc);
if (!timeSrc)
{
if (errorStr)
*errorStr = _("WARNING: Can't read file's timestamp: ") + pfd.source_file_absolute_native;
if (wxFileExists(pfd.source_file_absolute_native))
return true; // fall-back: Its better to compile in that case
return false;
}
// If the object file does not exist, then it must be built. In this case
// there is no need to scan the source file for headers.
time_t timeObj;
Compiler* compiler = target ? CompilerFactory::GetCompiler(target->GetCompilerID()) : m_pCompiler;
if (!compiler)
return false;
wxString ObjectAbs = (compiler->GetSwitches().UseFlatObjects)
? pfd.object_file_flat_absolute_native
: pfd.object_file_absolute_native;
depsTimeStamp(ObjectAbs.mb_str(), &timeObj);
if (!timeObj)
return true; // fall-back: Its better to compile in that case
// If the source file is newer than the object file, then the object file
// must be built. In this case there is no need to scan the source file
// for headers.
if (timeSrc > timeObj)
return true;
// Do the check for includes only, if not disabled by the user, e.g. in case of non C/C++ compilers
if ( Manager::Get()->GetConfigManager(_T("compiler"))->ReadBool(_T("/skip_include_deps"), false) )
return false;
// Scan the source file for headers. Result is NULL if the file does
// not exist. If one of the descendent header files is newer than the
// object file, then the object file must be built.
depsRef ref = depsScanForHeaders(pfd.source_file_absolute_native.mb_str());
if (ref)
{
time_t timeNewest;
(void) depsGetNewest(ref, &timeNewest);
return (timeNewest > timeObj);
}
// object file is up to date with source file and does not depend on #includes
return false;
}
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;
}
/** external deps are manually set by the user
* e.g. a static library linked to the project is an external dep (if set as such by the user)
* so that a re-linking is forced if the static lib is updated
*/
bool DirectCommands::AreExternalDepsOutdated(ProjectBuildTarget* target,
const wxString& buildOutput,
wxArrayString* filesMissing) const
{
Compiler* compiler = CompilerFactory::GetCompiler(target->GetCompilerID());
// if no output, probably a commands-only target; nothing to relink
// but we have to check other dependencies
time_t timeOutput = 0;
if (!buildOutput.IsEmpty())
{
wxString output = buildOutput;
Manager::Get()->GetMacrosManager()->ReplaceMacros(output);
depsTimeStamp(output.mb_str(), &timeOutput);
// if build output exists, check for updated static libraries
if (timeOutput)
{
// look for static libraries in target/project library dirs
wxArrayString libs = target->GetLinkLibs();
const wxArrayString& prjLibs = target->GetParentProject()->GetLinkLibs();
const wxArrayString& cmpLibs = compiler->GetLinkLibs();
AppendArray(prjLibs, libs);
AppendArray(cmpLibs, libs);
const wxArrayString& prjLibDirs = target->GetParentProject()->GetLibDirs();
const wxArrayString& cmpLibDirs = compiler->GetLibDirs();
wxArrayString libDirs = target->GetLibDirs();
AppendArray(prjLibDirs, libDirs);
AppendArray(cmpLibDirs, libDirs);
for (size_t i = 0; i < libs.GetCount(); ++i)
{
wxString lib = libs[i];
// if user manually pointed to a library, without using the lib dirs,
// then just check the file directly w/out involving the search dirs...
if (lib.Contains(_T("/")) || lib.Contains(_T("\\")))
{
Manager::Get()->GetMacrosManager()->ReplaceMacros(lib, target);
lib = UnixFilename(lib);
time_t timeExtDep;
depsTimeStamp(lib.mb_str(), &timeExtDep);
if (timeExtDep > timeOutput)
{
// force re-link
Manager::Get()->GetLogManager()->DebugLog(F(_T("Forcing re-link of '%s/%s' because '%s' is newer"),
target->GetParentProject()->GetTitle().wx_str(),
target->GetTitle().wx_str(),
lib.wx_str()));
return true;
}
continue;
}
if (!lib.StartsWith(compiler->GetSwitches().libPrefix))
lib = compiler->GetSwitches().libPrefix + lib;
if (!lib.EndsWith(_T(".") + compiler->GetSwitches().libExtension))
lib += _T(".") + compiler->GetSwitches().libExtension;
for (size_t l = 0; l < libDirs.GetCount(); ++l)
{
wxString dir = libDirs[l] + wxFILE_SEP_PATH + lib;
Manager::Get()->GetMacrosManager()->ReplaceMacros(dir, target);
dir = UnixFilename(dir);
time_t timeExtDep;
depsTimeStamp(dir.mb_str(), &timeExtDep);
if (timeExtDep > timeOutput)
{
// force re-link
Manager::Get()->GetLogManager()->DebugLog(F(_T("Forcing re-link of '%s/%s' because '%s' is newer"),
target->GetParentProject()->GetTitle().wx_str(),
target->GetTitle().wx_str(),
dir.wx_str()));
return true;
}
}
}
}
}
// array is separated by ;
wxArrayString extDeps = GetArrayFromString(target->GetExternalDeps(), _T(";"));
wxArrayString addFiles = GetArrayFromString(target->GetAdditionalOutputFiles(), _T(";"));
for (size_t i = 0; i < extDeps.GetCount(); ++i)
{
if (extDeps[i].IsEmpty())
continue;
Manager::Get()->GetMacrosManager()->ReplaceMacros(extDeps[i]);
time_t timeExtDep;
depsTimeStamp(extDeps[i].mb_str(), &timeExtDep);
// if external dep doesn't exist, no need to relink
// but we have to check other dependencies
if (!timeExtDep)
{
if (filesMissing) filesMissing->Add(extDeps[i]);
continue;
}
// let's check the additional output files
for (size_t j = 0; j < addFiles.GetCount(); ++j)
{
if (addFiles[j].IsEmpty())
continue;
Manager::Get()->GetMacrosManager()->ReplaceMacros(addFiles[j]);
time_t timeAddFile;
depsTimeStamp(addFiles[j].mb_str(), &timeAddFile);
// if additional file doesn't exist, we can skip it
if (!timeAddFile)
{
if (filesMissing) filesMissing->Add(addFiles[j]);
continue;
}
// if external dep is newer than additional file, relink
if (timeExtDep > timeAddFile)
return true;
}
// if no output, probably a commands-only target; nothing to relink
// but we have to check other dependencies
if (buildOutput.IsEmpty())
continue;
// now check the target's output
// this is moved last because, for "commands only" targets,
// it would return before we had a chance to check the
// additional output files (above)
// if build output doesn't exist, relink
if (!timeOutput)
return true;
// if external dep is newer than build output, relink
if (timeExtDep > timeOutput)
return true;
}
return false; // no force relink
}
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;
}