void MakeBuild::CleanPackage(const Workspace& wspc, int package)
{
PutConsole(NFormat("Cleaning %s", wspc[package]));
One<Host> host = CreateHost(false);
One<Builder> builder = CreateBuilder(~host);
if(!builder)
return;
host->DeleteFolderDeep(OutDir(PackageConfig(wspc, package, GetMethodVars(method), mainconfigparam,
*host, *builder), wspc[package], GetMethodVars(method)));
}
void Ide::Preprocess(bool asmout) {
if(editfile.IsEmpty())
return;
int pi = GetPackageIndex();
if(pi < 0) return;
SwitchHeader();
String pfn = ConfigFile(GetFileTitle(editfile) + ".i.tmp");
DeleteFile(pfn);
const Workspace& wspc = IdeWorkspace();
if(pi >= wspc.GetCount())
return;
One<Host> host = CreateHost(true);
One<Builder> b = CreateBuilder(~host);
Vector<String> linkfile;
String linkopt;
b->config = PackageConfig(wspc, pi, GetMethodVars(method), mainconfigparam, *host, *b);
console.Clear();
PutConsole((asmout ? "Compiling " : "Preprocessing ") + editfile);
b->Preprocess(wspc[pi], editfile, pfn, asmout);
HideBottom();
if(FileExists(pfn)) {
EditFile(pfn);
if(!editor.IsReadOnly())
ToggleReadOnly();
}
}
One<Builder> MakeBuild::CreateBuilder(Host *host)
{
SetupDefaultMethod();
VectorMap<String, String> bm = GetMethodVars(method);
String builder = bm.Get("BUILDER", "GCC");
int q = BuilderMap().Find(builder);
if(q < 0) {
PutConsole("Invalid builder " + builder);
ConsoleShow();
return NULL;
}
One<Builder> b = (*BuilderMap().Get(builder))();
b->host = host;
b->compiler = bm.Get("COMPILER", "");
b->include = SplitDirs(GetVar("UPP") + ';' + bm.Get("INCLUDE", "") + ';' + add_includes);
const Workspace& wspc = GetIdeWorkspace();
for(int i = 0; i < wspc.GetCount(); i++) {
const Package& pkg = wspc.GetPackage(i);
for(int j = 0; j < pkg.include.GetCount(); j++)
b->include.Add(SourcePath(wspc[i], pkg.include[j].text));
}
b->libpath = SplitDirs(bm.Get("LIB", ""));
b->debug_options = bm.Get("DEBUG_OPTIONS", "");
b->release_options = bm.Get("RELEASE_OPTIONS", "");
b->release_size_options = bm.Get("RELEASE_SIZE_OPTIONS", "");
b->debug_link = bm.Get("DEBUG_LINK", "");
b->release_link = bm.Get("RELEASE_LINK", "");
b->script = bm.Get("SCRIPT", "");
b->main_conf = !!main_conf.GetCount();
return b;
}
void Ide::BuildAndDebug0(const String& srcfile)
{
if(Build()) {
One<Host> h = CreateHostRunDir();
h->ChDir(GetFileFolder(target));
VectorMap<String, String> bm = GetMethodVars(method);
String dbg = bm.Get("DEBUGGER", Null);
if(IsNull(dbg)) {
if(bm.Get("BUILDER", Null) == "MSC71") {
String sln = ForceExt(target, ".sln");
if(GetFileLength(sln) > 0)
h->Launch("devenv \"" + h->GetHostPath(sln) + "\" "
// + "\"" + h->GetHostPath(srcfile) + "\"" //TRC, 2011/09/26: wrong devenv argument
);
else
h->Launch("devenv \"" + h->GetHostPath(target)
//+ "\" \"" + h->GetHostPath(srcfile) //TRC, 2011/09/26: wrong devenv argument
+ "\" /debugexe "
);
return;
}
dbg = "gdb";
}
else
h->Launch('\"' + dbg + "\" \""
// + h->GetHostPath(srcfile) + ' '
+ h->GetHostPath(target) + "\"", true);
}
}
void OutMode::Preset()
{
int q = ide.recent_buildmode.Find(~method);
SyncLock();
if(q < 0) {
VectorMap<String, String> map = GetMethodVars(~method);
debug.linkmode = atoi(map.Get("DEBUG_LINKMODE", "0"));
debug.debug = atoi(map.Get("DEBUG_INFO", "0"));
debug.blitz = MapFlag(map, "DEBUG_BLITZ");
release.linkmode = atoi(map.Get("RELEASE_LINKMODE", "0"));
release.debug <<= 0;
release.blitz = MapFlag(map, "RELEASE_BLITZ");
}
else {
StringStream ss(ide.recent_buildmode[q]);
TargetMode x;
String dummy;
int m;
ss / m;
ss % dummy;
ss / m;
mode = !!m;
ss % x;
debug.Load(x);
ss % x;
release.Load(x);
}
}
void Ide::BuildAndDebug(bool runto)
{
VectorMap<String, String> bm = GetMethodVars(method);
String builder = bm.Get("BUILDER", "");
if(!Build())
return;
if(!FileExists(target))
return;
if(designer)
EditAsText();
One<Host> host = CreateHostRunDir();
host->ChDir(Nvl(rundir, GetFileFolder(target)));
HideBottom();
editor.Disable();
#ifdef COMPILER_MSC
if(builder == "GCC")
if(gdbSelector)
debugger = Gdb_MI2Create(host, target, runarg);
else
debugger = GdbCreate(host, target, runarg);
else
debugger = PdbCreate(host, target, runarg);
#else
if(gdbSelector)
debugger = Gdb_MI2Create(host, target, runarg);
else
debugger = GdbCreate(host, target, runarg);
#endif
if(!debugger) return;
debuglock = 0;
const Workspace& wspc = IdeWorkspace();
for(int i = 0; i < wspc.GetCount(); i++) {
const Package& pk = wspc.GetPackage(i);
String n = wspc[i];
for(int i = 0; i < pk.file.GetCount(); i++) {
String file = SourcePath(n, pk.file[i]);
LineInfo& ln = Filedata(file).lineinfo;
for(int i = 0; i < ln.GetCount(); i++) {
LineInfoRecord& lr = ln[i];
if(!lr.breakpoint.IsEmpty())
if(!debugger->SetBreakpoint(file, lr.lineno, lr.breakpoint)) {
lr.breakpoint = "\xe";
if(PathIsEqual(file, editfile))
editor.SetBreakpoint(lr.lineno, "\xe");
}
}
}
}
SetBar();
editor.Enable();
if(runto) {
if(!debugger->RunTo())
IdeEndDebug();
}
else
debugger->Run();
}
bool MakeBuild::Build()
{
VectorMap<String, String> bm = GetMethodVars(method);
if(bm.GetCount() == 0) {
PutConsole("Invalid build method");
ConsoleShow();
return false;
}
One<Host> host = CreateHost(false);
One<Builder> builder = CreateBuilder(~host);
if(!builder)
return false;
Index<String> p = PackageConfig(GetIdeWorkspace(), 0, bm, mainconfigparam,
*host, *builder);
Workspace wspc;
wspc.Scan(GetMain(), p.GetKeys());
return Build(wspc, mainconfigparam, Null);
}
void Ide::SetupDefaultMethod()
{
if(IsNull(method)) {
SetMethod(GetDefaultMethod());
if(IsNull(method)) {
FindFile ff(ConfigFile("*.bm"));
if(!ff)
return;
SetMethod(GetFileTitle(ff.GetName()));
}
VectorMap<String, String> map = GetMethodVars(method);
debug.linkmode = atoi(map.Get("DEBUG_LINKMODE", "0"));
debug.def.debug = atoi(map.Get("DEBUG_INFO", "0"));
debug.def.blitz = MapFlag(map, "DEBUG_BLITZ");
release.linkmode = atoi(map.Get("RELEASE_LINKMODE", "0"));
release.def.debug <<= 0;
release.def.blitz = MapFlag(map, "RELEASE_BLITZ");
}
}
void MakeBuild::SetHdependDirs()
{
Vector<String> include = SplitDirs(GetVar("UPP") + ';'
+ GetMethodVars(method).Get("INCLUDE", "") + ';'
+ Environment().Get("INCLUDE", "")
#ifdef PLATFORM_POSIX
+ ";/usr/include;/usr/local/include;"
#endif
+ add_includes
);
// Also adding internal includes
const Workspace& wspc = GetIdeWorkspace();
for(int i = 0; i < wspc.GetCount(); i++) {
const Package& pkg = wspc.GetPackage(i);
for(int j = 0; j < pkg.include.GetCount(); j++)
include.Add(SourcePath(wspc[i], pkg.include[j].text));
}
HdependSetDirs(include);
}
void Ide::ConditionalBreak()
{
if(editfile.IsEmpty() || designer)
return;
int ln = editor.GetCursorLine();
String brk = editor.GetBreakpoint(ln);
if(brk == "\xe")
brk = "1";
Index<String> cfg = PackageConfig(IdeWorkspace(), 0, GetMethodVars(method), mainconfigparam,
*CreateHost(true), *CreateBuilder(~CreateHostRunDir()));
#ifdef COMPILER_MSC
if(cfg.Find("MSC") >= 0) {
if(EditPDBExpression("Conditional breakpoint", brk, NULL))
editor.SetBreakpoint(ln, brk);
}
else
#endif
if(EditText(brk, "Conditional breakpoint", "Condition"))
editor.SetBreakpoint(ln, brk);
editor.RefreshFrame();
}
One<Host> MakeBuild::CreateHost(bool sync_files)
{
SetupDefaultMethod();
VectorMap<String, String> bm = GetMethodVars(method);
One<Host> outhost;
{
One<LocalHost> host = new LocalHost;
VectorMap<String, String> env(Environment(), 1);
host->exedirs = SplitDirs(bm.Get("PATH", "") + ';' + env.Get("PATH", ""));
env.GetAdd("PATH") = Join(host->exedirs, ";");
env.GetAdd("UPP_MAIN__") = GetFileDirectory(PackagePath(GetMain()));
env.GetAdd("UPP_ASSEMBLY__") = GetVar("UPP");
for(int i = 0; i < env.GetCount(); i++) {
LDUMP(env.GetKey(i));
LDUMP(env[i]);
host->environment << env.GetKey(i) << '=' << env[i] << '\0';
}
host->environment.Cat(0);
host->cmdout = &cmdout;
outhost = -host;
}
return outhost;
}
void MakeBuild::SaveMakeFile(const String& fn, bool exporting)
{
BeginBuilding(false, true);
VectorMap<String, String> bm = GetMethodVars(method);
One<Host> host = CreateHost(false);
One<Builder> b = CreateBuilder(~host);
if(!b)
return;
const TargetMode& tm = GetTargetMode();
String makefile;
Vector<String> uppdirs = GetUppDirs();
String uppout = exporting ? host->GetHostPath(GetVar("OUTPUT")) : "_out/";
String inclist;
Index<String> allconfig = PackageConfig(GetIdeWorkspace(), 0, bm, mainconfigparam, *host, *b);
bool win32 = allconfig.Find("WIN32") >= 0;
Workspace wspc;
wspc.Scan(GetMain(), allconfig.GetKeys());
for(int i = 1; i < wspc.GetCount(); i++) {
Index<String> modconfig = PackageConfig(wspc, i, bm, mainconfigparam, *host, *b);
for(int a = allconfig.GetCount(); --a >= 0;)
if(modconfig.Find(allconfig[a]) < 0)
allconfig.Remove(a);
}
if(!exporting)
for(int i = 0; i < uppdirs.GetCount(); i++) {
String srcdir = GetMakePath(AdjustMakePath(host->GetHostPath(AppendFileName(uppdirs[i], ""))), win32);
makefile << "UPPDIR" << (i + 1) << " = " << srcdir << "\n";
inclist << " -I$(UPPDIR" << (i + 1) << ")";
}
else
inclist << "-I./";
Vector<String> includes = SplitDirs(bm.Get("INCLUDE",""));
for(int i = 0; i < includes.GetCount(); i++)
inclist << " -I" << includes[i];
makefile << "\n"
"UPPOUT = " << (exporting ? "_out/" : GetMakePath(AdjustMakePath(host->GetHostPath(AppendFileName(uppout, ""))), win32)) << "\n"
"CINC = " << inclist << "\n"
"Macro = ";
for(int i = 0; i < allconfig.GetCount(); i++)
makefile << " -Dflag" << allconfig[i];
makefile << "\n";
String output, config, install, rules, linkdep, linkfiles, linkfileend;
for(int i = 0; i < wspc.GetCount(); i++) {
b->config = PackageConfig(wspc, i, bm, mainconfigparam, *host, *b);
b->version = tm.version;
b->method = method;
MakeFile mf;
b->AddMakeFile(mf, wspc[i], GetAllUses(wspc, i),
GetAllLibraries(wspc, i, bm, mainconfigparam, *host, *b), allconfig,
exporting);
if(!i) {
String tdir = mf.outdir;
String trg;
if(tm.target_override) {
trg = GetMakePath(AdjustMakePath(tm.target), win32);
if(!trg.IsEmpty() && *trg.Last() == (win32 ? '\\' : '/'))
trg << mf.outfile;
else if(trg.Find(win32 ? '\\' : '/') < 0)
trg.Insert(0, "$(OutDir)");
}
output = Nvl(trg, mf.output);
if(exporting)
output = wspc[i] + ".out";
install << "\n"
"OutDir = " << tdir << "\n"
"OutFile = " << output << "\n"
"\n"
".PHONY: all\n"
"all: prepare $(OutFile)\n"
"\n"
".PHONY: prepare\n"
"prepare:\n";
}
config << mf.config;
install << mf.install;
rules << mf.rules;
linkdep << mf.linkdep;
linkfiles << mf.linkfiles;
linkfileend << mf.linkfileend;
}
makefile
<< config
<< install
<< "\n"
"$(OutFile): " << linkdep << "\n\t" << linkfiles << linkfileend << " -Wl,--end-group\n\n"
<< rules
<< ".PHONY: clean\n"
<< "clean:\n"
<< "\tif [ -d $(UPPOUT) ]; then rm -rf $(UPPOUT); fi;\n";
bool sv = ::SaveFile(fn, makefile);
if(!exporting)
if(sv)
PutConsole(NFormat("%s(1): makefile generation complete", fn));
else
PutConsole(NFormat("%s: error writing makefile", fn));
EndBuilding(true);
}
bool MakeBuild::Build(const Workspace& wspc, String mainparam, String outfile, bool clear_console)
{
String hfile = outfile + ".xxx";
SaveFile(hfile, "");
FileTime start_time = GetFileTime(hfile); // Defensive way to get correct filetime of start
DeleteFile(hfile);
ClearErrorEditor();
BeginBuilding(true, clear_console);
bool ok = true;
if(wspc.GetCount()) {
for(int i = 0; i < wspc.GetCount(); i++) {
const Package& pk = wspc.package[i];
for(int j = 0; j < pk.GetCount(); j++)
if(pk[j] == "main.conf") {
String pn = wspc[i];
String p = SourcePath(pn, "main.conf");
main_conf << "// " << pn << "\r\n" << LoadFile(p) << "\r\n";
PutConsole("Found " + p);
}
}
if(main_conf.GetCount()) {
VectorMap<String, String> bm = GetMethodVars(method);
One<Host> host = CreateHost(false);
One<Builder> b = CreateBuilder(~host);
if(b) {
Index<String> mcfg = PackageConfig(wspc, 0, bm, mainparam, *host, *b, NULL);
String outdir = OutDir(mcfg, wspc[0], bm, false);
String path = AppendFileName(outdir, "main.conf.h");
RealizePath(path);
SaveChangedFile(path, main_conf);
PutConsole("Saving " + path);
add_includes << outdir << ';';
}
}
Vector<int> build_order;
if(GetTargetMode().linkmode != 2) {
for(int i = 1; i < wspc.GetCount(); i++)
build_order.Add(i);
}
else {
Index<int> remaining;
for(int i = 1; i < wspc.GetCount(); i++)
remaining.Add(i);
while(!remaining.IsEmpty()) {
int t;
for(t = 0; t < remaining.GetCount(); t++) {
const Package& pk = wspc.package[remaining[t]];
bool delay = false;
for(int u = 0; u < pk.uses.GetCount(); u++)
if(remaining.Find(wspc.package.Find(pk.uses[u].text)) >= 0) {
delay = true;
break;
}
if(!delay)
break;
}
if(t >= remaining.GetCount())
t = 0;
build_order.Add(remaining[t]);
remaining.Remove(t);
}
}
String mainpackage = wspc[0];
Vector<String> linkfile;
String linkopt = GetMethodVars(method).Get(targetmode ? "RELEASE_LINK" : "DEBUG_LINK", Null);
if(linkopt.GetCount())
linkopt << ' ';
ok = true;
int ms = msecs();
for(int i = 0; i < build_order.GetCount() && (ok || !stoponerrors); i++) {
int px = build_order[i];
ok = BuildPackage(wspc, px, i, build_order.GetCount() + 1,
mainparam, Null, linkfile, linkopt) && ok;
if(msecs() - ms >= 200) {
DoProcessEvents();
ms = msecs();
}
}
if(ok || !stoponerrors) {
ok = BuildPackage(wspc, 0, build_order.GetCount(), build_order.GetCount() + 1,
mainparam, outfile, linkfile, linkopt, ok) && ok;
// Set the time of target to start-time, so that if any file changes during
// compilation, it is recompiled during next build
SetFileTime(target, start_time);
}
}
EndBuilding(ok);
ReQualifyCodeBase();
SetErrorEditor();
return ok;
}
bool MakeBuild::BuildPackage(const Workspace& wspc, int pkindex, int pknumber, int pkcount,
String mainparam, String outfile, Vector<String>& linkfile, String& linkopt, bool link)
{
String package = wspc[pkindex];
String mainpackage = wspc[0];
const Package& pkg = wspc.package[pkindex];
VectorMap<String, String> bm = GetMethodVars(method);
if(bm.GetCount() == 0) {
PutConsole("Invalid build method");
ConsoleShow();
return false;
}
One<Host> host = CreateHost(false);
if(!IsNull(onefile)) {
OneFileHost *h = new OneFileHost;
h->host = host;
h->onefile = onefile;
host = h;
}
One<Builder> b = CreateBuilder(~host);
if(!b)
return false;
b->config = PackageConfig(wspc, pkindex, bm, mainparam, *host, *b);
const TargetMode& m = targetmode == 0 ? debug : release;
b->version = m.version;
b->method = method;
b->outdir = OutDir(b->config, package, bm);
host->RealizeDir(b->outdir);
String mainfn = Null;
Index<String> mcfg = PackageConfig(wspc, 0, bm, mainparam, *host, *b, &mainfn);
HdependClearDependencies();
for(int i = 0; i < pkg.GetCount(); i++) {
const Array<OptItem>& f = pkg[i].depends;
for(int j = 0; j < f.GetCount(); j++)
if(MatchWhen(f[j].when, mcfg.GetKeys()))
HdependAddDependency(SourcePath(package, pkg[i]), SourcePath(package, f[j].text));
}
String tout = OutDir(mcfg, mainpackage, bm, use_target);
host->RealizeDir(tout);
if(IsNull(mainfn))
mainfn = GetFileTitle(mainpackage) + b->GetTargetExt();
if(!IsNull(outfile))
target = NormalizePath(outfile, tout);
else {
if(m.target_override && !IsNull(m.target) && IsFolder(m.target))
target = host->NormalizePath(AppendFileName(m.target, mainfn));
else
if(m.target_override && (IsFullPath(m.target) || *m.target == '/' || *m.target == '\\'))
target = m.target;
else
if(m.target_override && !IsNull(m.target))
target = host->NormalizePath(AppendFileName(tout, m.target));
else
if(IsFullPath(mainfn))
target = mainfn;
else
target = host->NormalizePath(AppendFileName(tout, mainfn));
}
b->target = target;
b->mainpackage = mainpackage;
if(IsNull(onefile)) {
String out;
out << "----- " << package << " ( " << Join(b->config.GetKeys(), " ") << " )";
if(pkcount > 1)
out << " (" << (pknumber + 1) << " / " << pkcount << ')';
PutConsole(out);
}
else
b->config.FindAdd("NOLIB");
bool ok = b->BuildPackage(package, linkfile, linkopt,
GetAllUses(wspc, pkindex),
GetAllLibraries(wspc, pkindex, bm, mainparam, *host, *b),
targetmode - 1);
Vector<String> errors = PickErrors();
host->DeleteFile(errors);
if(!ok || !errors.IsEmpty())
return false;
if(link) {
ok = b->Link(linkfile, linkopt, GetTargetMode().createmap);
errors = PickErrors();
host->DeleteFile(errors);
if(!ok || !errors.IsEmpty())
return false;
}
return true;
}
void Ide::SetMethod(const String& m)
{
method = m;
current_builder = GetMethodVars(method).Get("BUILDER", "");
NewCodeBase();
}
void OutMode::SyncLock()
{
bool b = GetMethodVars(~method).Get("LINKMODE_LOCK", "") != "1";
release.linkmode.Enable(b);
debug.linkmode.Enable(b);
}
