void MainConfigDlg::FlagDlg()
{
WithConfLayout<TopWindow> cfg;
CtrlLayoutOKCancel(cfg, "Configuration flags");
cfg.Sizeable().MaximizeBox();
Vector<String> flg = SplitFlags0(String(fe));
Vector<String> accepts = wspc.GetAllAccepts(0);
Sort(accepts, GetLanguageInfo());
enum { CC_SET, CC_NAME, CC_PACKAGES, CC_COUNT };
cfg.accepts.AddColumn("Set").Ctrls(sSetOption).HeaderTab().Fixed(40);
cfg.accepts.AddColumn("Flag", 1);
cfg.accepts.AddColumn("Packages", 2);
cfg.accepts.SetCount(accepts.GetCount());
for(int i = 0; i < accepts.GetCount(); i++) {
String acc = accepts[i];
Vector<String> pkg;
for(int p = 0; p < wspc.GetCount(); p++)
if(FindIndex(wspc.package[p].accepts, acc) >= 0)
pkg.Add(wspc[p]);
Sort(pkg, GetLanguageInfo());
cfg.accepts.Set(i, CC_NAME, accepts[i]);
cfg.accepts.Set(i, CC_PACKAGES, Join(pkg, ","));
}
cfg.other.SetFilter(FlagFilterM);
cfg.dll <<= cfg.gui <<= cfg.mt <<= cfg.sse2 <<= 0;
String other;
for(int i = 0; i < flg.GetCount(); i++) {
String f = flg[i];
if(!SetSw(f, cfg.dll, "DLL")
&& !SetSw(f, cfg.gui, "GUI")
&& !SetSw(f, cfg.mt, "MT")
&& !SetSw(f, cfg.sse2, "SSE2")) {
int x = (*f == '.' ? cfg.accepts.Find(f.Mid(1), CC_NAME) : -1);
if(x >= 0)
cfg.accepts.Set(x, CC_SET, true);
else {
if(!other.IsEmpty())
other << ' ';
other << f;
}
}
}
cfg.other <<= other;
if(cfg.Run() == IDOK) {
String flags;
flags
<< GetSw(cfg.dll, "DLL")
<< GetSw(cfg.gui, "GUI")
<< GetSw(cfg.mt, "MT")
<< GetSw(cfg.sse2, "SSE2");
for(int i = 0; i < cfg.accepts.GetCount(); i++)
if(cfg.accepts.Get(i, CC_SET))
flags << '.' << cfg.accepts.Get(i, CC_NAME) << ' ';
flags << cfg.other.GetText().ToString();
fe = Join(SplitFlags0(flags), " ").ToWString();
}
}
int DlgCompareDir::Refresh(String rel_path, int parent)
{
FindFile ff;
VectorMap<String, FileInfo> afile, bfile;
VectorMap<String, String> adir, bdir;
String arel = AppendFileName(pa, rel_path);
String brel = AppendFileName(pb, rel_path);
int done = 0;
if(!FetchDir(arel, afile, adir))
done |= 2;
if(!FetchDir(brel, bfile, bdir))
done |= 1;
Index<String> dir_index;
dir_index <<= adir.GetIndex();
FindAppend(dir_index, bdir.GetKeys());
Vector<String> dirs(dir_index.PickKeys());
Sort(dirs, GetLanguageInfo());
for(int i = 0; i < dirs.GetCount(); i++) {
int fa = adir.Find(dirs[i]), fb = bdir.Find(dirs[i]);
String dn = (fb >= 0 ? bdir[fb] : adir[fa]);
int dirpar = tree.Add(parent, CtrlImg::Dir(), dn);
int dirdone = Refresh(AppendFileName(rel_path, dirs[i]), dirpar);
done |= dirdone;
switch(dirdone) {
case 0: tree.Remove(dirpar); break;
case 1: tree.SetNode(dirpar, TreeCtrl::Node().SetImage(CompDirImg::a_dir()).Set(dn)); break;
case 2: tree.SetNode(dirpar, TreeCtrl::Node().SetImage(CompDirImg::b_dir()).Set(dn)); break;
case 3: tree.SetNode(dirpar, TreeCtrl::Node().SetImage(CompDirImg::ab_dir()).Set(dn)); break;
}
}
Index<String> name_index;
name_index <<= afile.GetIndex();
FindAppend(name_index, bfile.GetKeys());
Vector<String> names(name_index.PickKeys());
Sort(names, GetLanguageInfo());
for(int i = 0; i < names.GetCount(); i++) {
int fa = afile.Find(names[i]), fb = bfile.Find(names[i]);
if(fa < 0) {
tree.Add(parent, CompDirImg::b_file(), NFormat("%s: B (%`, %0n)", bfile[fb].name, bfile[fb].time, bfile[fb].size));
done |= 2;
}
else if(fb < 0) {
tree.Add(parent, CompDirImg::a_file(), NFormat("%s: A (%`, %0n)", afile[fa].name, afile[fa].time, afile[fa].size));
done |= 1;
}
else if(afile[fa].size != bfile[fb].size
|| LoadFile(AppendFileName(arel, names[i])) != LoadFile(AppendFileName(brel, names[i]))) {
tree.Add(parent, CompDirImg::ab_file(), NFormat("%s: A (%`, %0n), B (%`, %0n)",
bfile[fb].name, afile[fa].time, afile[fa].size, bfile[fb].time, bfile[fb].size));
done |= 3;
}
}
return done;
}
void ScreenSelectLanguage::Init()
{
// fill m_aGameCommands before calling Init()
vector<RString> vs;
THEME->GetLanguages( vs );
SortRStringArray( vs, true );
FOREACH_CONST( RString, vs, s )
{
const LanguageInfo *pLI = GetLanguageInfo( *s );
GameCommand gc;
gc.m_iIndex = s - vs.begin();
gc.m_sName = *s;
gc.m_bInvalid = false;
if( pLI )
gc.m_sText = THEME->GetString("NativeLanguageNames", pLI->szEnglishName);
else
gc.m_sText = *s;
m_aGameCommands.push_back( gc );
}
ScreenSelectMaster::Init();
}
/* static */
wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory WXUNUSED(cat))
{
wxUint32 lcid = LOCALE_USER_DEFAULT;
if ( wxGetLocale() )
{
const wxLanguageInfo * const
info = GetLanguageInfo(wxGetLocale()->GetLanguage());
if ( info )
lcid = info->GetLCID();
}
wxString str;
wxChar buf[256];
buf[0] = wxT('\0');
switch ( index )
{
case wxLOCALE_DECIMAL_POINT:
if ( ::GetLocaleInfo(lcid, LOCALE_SDECIMAL, buf, WXSIZEOF(buf)) )
str = buf;
break;
case wxLOCALE_SHORT_DATE_FMT:
case wxLOCALE_LONG_DATE_FMT:
case wxLOCALE_TIME_FMT:
if ( ::GetLocaleInfo(lcid, GetLCTYPEFormatFromLocalInfo(index),
buf, WXSIZEOF(buf)) )
{
return TranslateFromUnicodeFormat(buf);
}
break;
case wxLOCALE_DATE_TIME_FMT:
// there doesn't seem to be any specific setting for this, so just
// combine date and time ones
//
// we use the short date because this is what "%c" uses by default
// ("%#c" uses long date but we have no way to specify the
// alternate representation here)
{
const wxString datefmt = GetInfo(wxLOCALE_SHORT_DATE_FMT);
if ( datefmt.empty() )
break;
const wxString timefmt = GetInfo(wxLOCALE_TIME_FMT);
if ( timefmt.empty() )
break;
str << datefmt << ' ' << timefmt;
}
break;
default:
wxFAIL_MSG( "unknown wxLocaleInfo" );
}
return str;
}
Vector<String> LoadSchemaStrColumn(SqlId column, const SqlId& table, SqlSession& session, bool order)
{
Vector<String> result;
FetchContainer(result, Select(column).FromSchema(table), session);
if(order)
Sort(result, GetLanguageInfo());
return result;
}
/* static */
wxString wxLocale::GetLanguageCanonicalName(int lang)
{
if ( lang == wxLANGUAGE_DEFAULT || lang == wxLANGUAGE_UNKNOWN )
return wxEmptyString;
const wxLanguageInfo *info = GetLanguageInfo(lang);
if ( !info )
return wxEmptyString;
else
return info->CanonicalName;
}
Vector<String> HelpTopicList(String chksp, String chkne)
{
Vector<String> out;
const HelpTopicInfoMap& map = HelpTopicMap();
if(IsNull(chksp) && IsNull(chkne))
out <<= map.GetKeys();
else
{
for(int i = 0; i < map.GetCount(); i++)
{
String space, nesting, topic;
HelpParseDPP(map.GetKey(i), space, nesting, topic);
if((IsNull(chksp) || chksp == Nvl(space, "::")) && (IsNull(chkne) || chkne == Nvl(nesting, "::")))
out.Add(map.GetKey(i));
}
}
Sort(out, GetLanguageInfo());
return out;
}
int StdValueCompare(const Value& a, const Value& b, int language)
{
LTIMING("StdValueCompare");
bool na = IsNull(a), nb = IsNull(b);
if(na || nb)
return !na ? 1 : !nb ? -1 : 0;
dword ta = a.GetType(), tb = b.GetType();
if((ta == INT_V || ta == BOOL_V) && (tb == INT_V || tb == BOOL_V))
return cmp<int>(a, b);
if((ta == BOOL_V || ta == INT_V || ta == INT64_V || ta == DOUBLE_V)
&& (tb == BOOL_V || tb == INT_V || tb == INT64_V || tb == DOUBLE_V))
return cmp<double>(a, b);
if(ta == DATE_V && tb == DATE_V)
return cmp<Date>(a, b);
if((ta == DATE_V || ta == TIME_V) && (tb == DATE_V || tb == TIME_V))
return cmp<Time>(a, b);
if((ta == STRING_V || ta == WSTRING_V) && (tb == STRING_V || tb == WSTRING_V))
return GetLanguageInfo(language).Compare(WString(a), WString(b));
return a.Compare(b);
}
const LanguageInfo& GetLanguageInfo()
{
return GetLanguageInfo(GetCurrentLanguage());
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::AnalyzeAggregateCall(CallInstr* callInstr,
OperandVariableDict& opDict) {
// Check if any of the arguments is in the dictionary.
// If we call a function from the standard library we may be able
// to prove that the address is not taken.
if(callInstr->HasArguments() == false) {
return;
}
// Check if we have a 'copyMemory' or 'setMemory' intrinsic call.
// These are frequently used for record copy operations.
CallInstr::ArgumentList& arguments = *callInstr->Arguments();
if(auto intrinsic = callInstr->GetIntrinsic()) {
if(intrinsic->Is<CopyMemoryIntr>() ||
intrinsic->Is<SetMemoryIntr>()) {
return;
}
}
if(callInstr->CalledFunctionType()->IsVarargs()) {
// Mark all arguments as address taken.
for(int i = 0; i < arguments.Count(); i++) {
if(opDict.ContainsKey(arguments[i])) {
opDict[arguments[i]].PairVariable->SetIsAddresTaken(true);
}
}
return;
}
for(int i = 0; i < arguments.Count(); i++) {
if(opDict.ContainsKey(arguments[i]) == false) {
continue;
}
// Check if this is a record that is passed "by value",
// meaning that we're guaranteed that the address
// doesn't escape the called function.
if(auto pointerType = arguments[i]->GetType()->As<PointerType>()) {
if(pointerType->PointeeType()->IsRecord()) {
// We should call a known function, so that we can
// check the attributes of the parameters.
if(auto function = callInstr->GetCalledFunction()) {
auto parameter = function->GetParameter(i);
if(parameter->IsNoEscape()) {
continue;
}
}
}
}
// Check if the behavior of the function is known
// because it's part of the standard library.
if(auto info = GetLanguageInfo()) {
bool paramReturned = false;
if(info->CallMayCaptureParameter(callInstr, i, ¶mReturned)) {
// Track the parameter if it's only returned.
// Otherwise presume its address is taken.
if(paramReturned) {
auto destOp = callInstr->GetDestinationOp();
opDict.Add(destOp, OVPair(destOp, opDict[arguments[i]].PairVariable));
continue;
}
}
else continue;
}
// Presume address it's taken.
opDict[arguments[i]].PairVariable->SetIsAddresTaken(true);
}
}
bool wxLocale::Init(int language, int flags)
{
#if WXWIN_COMPATIBILITY_2_8
wxASSERT_MSG( !(flags & wxLOCALE_CONV_ENCODING),
wxS("wxLOCALE_CONV_ENCODING is no longer supported, add charset to your catalogs") );
#endif
bool ret = true;
int lang = language;
if (lang == wxLANGUAGE_DEFAULT)
{
// auto detect the language
lang = GetSystemLanguage();
}
// We failed to detect system language, so we will use English:
if (lang == wxLANGUAGE_UNKNOWN)
{
return false;
}
const wxLanguageInfo *info = GetLanguageInfo(lang);
// Unknown language:
if (info == NULL)
{
wxLogError(wxS("Unknown language %i."), lang);
return false;
}
wxString name = info->Description;
wxString canonical = info->CanonicalName;
wxString locale;
// Set the locale:
#if defined(__OS2__)
const char *retloc = wxSetlocale(LC_ALL , wxEmptyString);
#elif defined(__UNIX__) && !defined(__WXMAC__)
if (language != wxLANGUAGE_DEFAULT)
locale = info->CanonicalName;
const char *retloc = wxSetlocaleTryUTF8(LC_ALL, locale);
const wxString langOnly = ExtractLang(locale);
if ( !retloc )
{
// Some C libraries don't like xx_YY form and require xx only
retloc = wxSetlocaleTryUTF8(LC_ALL, langOnly);
}
#if wxUSE_FONTMAP
// some systems (e.g. FreeBSD and HP-UX) don't have xx_YY aliases but
// require the full xx_YY.encoding form, so try using UTF-8 because this is
// the only thing we can do generically
//
// TODO: add encodings applicable to each language to the lang DB and try
// them all in turn here
if ( !retloc )
{
const wxChar **names =
wxFontMapperBase::GetAllEncodingNames(wxFONTENCODING_UTF8);
while ( *names )
{
retloc = wxSetlocale(LC_ALL, locale + wxS('.') + *names++);
if ( retloc )
break;
}
}
#endif // wxUSE_FONTMAP
if ( !retloc )
{
// Some C libraries (namely glibc) still use old ISO 639,
// so will translate the abbrev for them
wxString localeAlt;
if ( langOnly == wxS("he") )
localeAlt = wxS("iw") + ExtractNotLang(locale);
else if ( langOnly == wxS("id") )
localeAlt = wxS("in") + ExtractNotLang(locale);
else if ( langOnly == wxS("yi") )
localeAlt = wxS("ji") + ExtractNotLang(locale);
else if ( langOnly == wxS("nb") )
localeAlt = wxS("no_NO");
else if ( langOnly == wxS("nn") )
localeAlt = wxS("no_NY");
if ( !localeAlt.empty() )
{
retloc = wxSetlocaleTryUTF8(LC_ALL, localeAlt);
if ( !retloc )
retloc = wxSetlocaleTryUTF8(LC_ALL, ExtractLang(localeAlt));
}
}
if ( !retloc )
ret = false;
#ifdef __AIX__
// at least in AIX 5.2 libc is buggy and the string returned from
// setlocale(LC_ALL) can't be passed back to it because it returns 6
// strings (one for each locale category), i.e. for C locale we get back
// "C C C C C C"
//
// this contradicts IBM own docs but this is not of much help, so just work
// around it in the crudest possible manner
char* p = const_cast<char*>(wxStrchr(retloc, ' '));
if ( p )
*p = '\0';
#endif // __AIX__
#elif defined(__WIN32__)
const char *retloc = "C";
if ( language != wxLANGUAGE_DEFAULT )
{
if ( info->WinLang == 0 )
{
wxLogWarning(wxS("Locale '%s' not supported by OS."), name.c_str());
// retloc already set to "C"
}
else // language supported by Windows
{
// Windows CE doesn't have SetThreadLocale() and there doesn't seem
// to be any equivalent
#ifndef __WXWINCE__
const wxUint32 lcid = info->GetLCID();
// change locale used by Windows functions
::SetThreadLocale(lcid);
#endif
// and also call setlocale() to change locale used by the CRT
locale = info->GetLocaleName();
if ( locale.empty() )
{
ret = false;
}
else // have a valid locale
{
retloc = wxSetlocale(LC_ALL, locale);
}
}
}
else // language == wxLANGUAGE_DEFAULT
{
retloc = wxSetlocale(LC_ALL, wxEmptyString);
}
#if wxUSE_UNICODE && (defined(__VISUALC__) || defined(__MINGW32__))
// VC++ setlocale() (also used by Mingw) can't set locale to languages that
// can only be written using Unicode, therefore wxSetlocale() call fails
// for such languages but we don't want to report it as an error -- so that
// at least message catalogs can be used.
if ( !retloc )
{
if ( wxGetANSICodePageForLocale(LOCALE_USER_DEFAULT).empty() )
{
// we set the locale to a Unicode-only language, don't treat the
// inability of CRT to use it as an error
retloc = "C";
}
}
#endif // CRT not handling Unicode-only languages
if ( !retloc )
ret = false;
#elif defined(__WXMAC__)
if (lang == wxLANGUAGE_DEFAULT)
locale = wxEmptyString;
else
locale = info->CanonicalName;
const char *retloc = wxSetlocale(LC_ALL, locale);
if ( !retloc )
{
// Some C libraries don't like xx_YY form and require xx only
retloc = wxSetlocale(LC_ALL, ExtractLang(locale));
}
#else
wxUnusedVar(flags);
return false;
#define WX_NO_LOCALE_SUPPORT
#endif
#ifndef WX_NO_LOCALE_SUPPORT
if ( !ret )
{
wxLogWarning(_("Cannot set locale to language \"%s\"."), name.c_str());
// continue nevertheless and try to load at least the translations for
// this language
}
if ( !DoInit(name, canonical, retloc) )
{
ret = false;
}
if (IsOk()) // setlocale() succeeded
m_language = lang;
// NB: don't use 'lang' here, 'language'
wxTranslations *t = wxTranslations::Get();
if ( t )
{
t->SetLanguage(static_cast<wxLanguage>(language));
if ( flags & wxLOCALE_LOAD_DEFAULT )
t->AddStdCatalog();
}
return ret;
#endif // !WX_NO_LOCALE_SUPPORT
}
void CppBuilder::AddMakeFile(MakeFile& makefile, String package,
const Vector<String>& all_uses, const Vector<String>& all_libraries,
const Index<String>& common_config, bool exporting)
{
String packagepath = PackagePath(package);
Package pkg;
pkg.Load(packagepath);
String packagedir = GetFileFolder(packagepath);
Vector<String> src = GetUppDirs();
for(int i = 0; i < src.GetCount(); i++)
src[i] = UnixPath(src[i]);
bool main = HasFlag("MAIN");
bool is_shared = HasFlag("SO");
bool libout = !main && !HasFlag("NOLIB");
bool win32 = HasFlag("WIN32");
String pack_ident = MakeIdent(package);
String outdir = "OutDir_" + pack_ident;
String macros = "Macro_" + pack_ident;
String macdef = "$(Macro)";
String objext = (HasFlag("MSC") || HasFlag("EVC") ? ".obj" : ".o");
Vector<String> x(config.GetKeys(), 1);
Sort(x);
for(int i = 0; i < x.GetCount(); i++) {
if(common_config.Find(x[i]) < 0)
macdef << " -Dflag" << x[i];
x[i] = InitCaps(x[i]);
}
makefile.outdir << "$(" << outdir << ")";
makefile.outfile << AdjustMakePath(GetFileTitle(NativePath(package)));
if(main)
makefile.outfile << GetTargetExt();
else if(is_shared)
makefile.outfile << (win32 ? ".dll" : ".so");
else
makefile.outfile << (win32 && HasFlag("MSC") ? ".lib" : ".a");
makefile.output << (main ? String("$(OutDir)") : makefile.outdir) << makefile.outfile;
if(main) {
makefile.config << "CXX = c++\n"
"LINKER = $(CXX)\n";
String flags;
if(HasFlag("DEBUG"))
flags << " -D_DEBUG " << debug_options;
else
flags << ' ' << release_options;
if(HasFlag("DEBUG_MINIMAL"))
flags << " -ggdb -g1";
if(HasFlag("DEBUG_FULL"))
flags << " -ggdb -g2";
if(is_shared && !win32)
flags << " -fPIC ";
flags << ' ' << Gather(pkg.option, config.GetKeys());
makefile.config << "CFLAGS =" << flags << "\n"
"CXXFLAGS =" << flags << "\n"
"LDFLAGS = " << (HasFlag("DEBUG") ? debug_link : release_link) << " $(LINKOPTIONS)\n"
"LIBPATH =";
for(int i = 0; i < libpath.GetCount(); i++)
makefile.config << " -L" << GetMakePath(AdjustMakePath(GetHostPathQ(libpath[i])));
makefile.config << "\n"
"AR = ar -sr\n\n";
makefile.install << "\t-mkdir -p $(OutDir)\n";
Vector<String> lib;
String lnk;
lnk << "$(LINKER)";
if(!HasFlag("SHARED"))
lnk << " -static";
if(HasFlag("WIN32")) {
lnk << " -mwindows";
if(!HasFlag("GUI"))
makefile.linkfiles << " -mconsole";
}
lnk << " -o $(OutFile)";
if(HasFlag("DEBUG") || HasFlag("DEBUG_MINIMAL") || HasFlag("DEBUG_FULL"))
lnk << " -ggdb";
else
lnk << (!HasFlag("OSX11") ? " -Wl,-s" : "");
lnk << " $(LIBPATH)";
if (!HasFlag("OSX11"))
lnk << " -Wl,-O,2";
lnk << " $(LDFLAGS) -Wl,--start-group ";
makefile.linkfiles = lnk;
}
makefile.config << outdir << " = $(UPPOUT)"
<< GetMakePath(AdjustMakePath(String().Cat() << package << '/' << method << '-' << Join(x, "-") << '/')) << "\n"
<< macros << " = " << macdef << "\n";
makefile.install << "\t-mkdir -p $(" << outdir << ")\n";
String libdep, libfiles;
libdep << makefile.output << ":";
if(is_shared)
{
libfiles = "c++ -shared -fPIC"; // -v";
Point p = ExtractVersion();
if(!IsNull(p.x)) {
libfiles << " -Xlinker --major-image-version -Xlinker " << p.x;
if(!IsNull(p.y))
libfiles << " -Xlinker --minor-image-version -Xlinker " << p.y;
}
libfiles << " -o ";
}
else
libfiles = "$(AR) ";
libfiles << makefile.output;
Vector<String> libs = Split(Gather(pkg.library, config.GetKeys()), ' ');
for(int i = 0; i < libs.GetCount(); i++) {
String ln = libs[i];
String ext = ToLower(GetFileExt(ln));
if(ext == ".a" || ext == ".so" || ext == ".dll")
makefile.linkfileend << " \\\n\t\t\t" << GetHostPathQ(FindInDirs(libpath, ln));
else
makefile.linkfileend << " \\\n\t\t\t-l" << ln;
}
for(int i = 0; i < pkg.GetCount(); i++)
if(!pkg[i].separator) {
String gop = Gather(pkg[i].option, config.GetKeys());
String fn = SourcePath(package, pkg[i]);
String ext = ToLower(GetFileExt(fn));
bool isc = ext == ".c";
bool isrc = (ext == ".rc" && HasFlag("WIN32"));
bool iscpp = (ext == ".cpp" || ext == ".cc" || ext == ".cxx");
bool isicpp = (ext == ".icpp");
if(ext == ".brc") {
isc = true;
fn << "c";
}
if(isc || isrc || iscpp || isicpp) {
String outfile;
outfile << makefile.outdir << AdjustMakePath(GetFileTitle(fn)) << (isrc ? "_rc" : "") << objext;
String srcfile = GetMakePath(MakeSourcePath(src, fn, false, exporting));
makefile.rules << outfile << ": " << srcfile;
Vector<String> dep = HdependGetDependencies(fn);
Sort(dep, GetLanguageInfo());
for(int d = 0; d < dep.GetCount(); d++) {
String dfn = MakeSourcePath(src, dep[d], true, exporting);
if(!IsNull(dfn))
makefile.rules << " \\\n\t" << GetMakePath(dfn);
}
makefile.rules << "\n"
"\t$(CXX) -c " << (isc ? "-x c $(CFLAGS)" : "-x c++ $(CXXFLAGS)") << " $(CINC) $(" << macros << ") "
<< gop << " " << srcfile << " -o " << outfile << "\n\n";
if(!libout || isicpp) {
makefile.linkdep << " \\\n\t" << outfile;
makefile.linkfiles << " \\\n\t\t" << outfile;
}
else {
libdep << " \\\n\t" << outfile;
libfiles << " \\\n\t\t" << outfile;
}
}
else
if(ext == ".o" || ext == ".obj" || ext == ".a" || ext == ".so" || ext == ".lib" || ext == ".dll") {
makefile.linkdep << " \\\n\t" << fn;
makefile.linkfiles << ' ' << fn;
}
}
if(libout) {
makefile.rules << libdep << "\n\t" << libfiles << "\n\n";
makefile.linkdep << " \\\n\t" << makefile.output;
makefile.linkfiles << " \\\n\t\t\t" << makefile.output;
}
/*
if(main) {
if(!HasFlag("SOLARIS")&&!HasFlag("OSX11"))
makefile.linkfiles << " \\\n\t\t-Wl,--start-group ";
DDUMPC(all_libraries);
for(int i = 0; i < all_libraries.GetCount(); i++) {
String ln = all_libraries[i];
String ext = ToLower(GetFileExt(ln));
if(ext == ".a" || ext == ".so" || ext == ".dll")
makefile.linkfileend << " \\\n\t\t\t" << GetHostPathQ(FindInDirs(libpath, ln));
else
makefile.linkfileend << " \\\n\t\t\t-l" << ln;
}
if(!HasFlag("SOLARIS")&&!HasFlag("OSX11"))
makefile.linkfileend << " \\\n\t\t-Wl,--end-group\n\n";
}
*/
}