void WorkspaceWork::SyncErrorPackages()
{
for(int i = 0; i < package.GetCount(); i++) {
FileList::File f = package.Get(i);
if(!IsAux(f.name) && i < speed.GetCount()) {
FileList::File ff = f;
String path = GetFileFolder(PackagePath(f.name));
#ifdef PLATFORM_WIN32
path = ToLower(path);
#endif
ff.icon = i ? IdeImg::Package() : IdeImg::MainPackage();
if(speed[i])
ff.icon = ImageOver(ff.icon, IdeImg::FastPackage());
ff.underline = Null;
for(int q = 0; q < errorfiles.GetCount(); q++) {
if(errorfiles[q].StartsWith(path)) {
ff.icon = ImageOverRed(ff.icon);
ff.underline = LtRed;
break;
}
}
ff.icon = DPI(ff.icon);
package.Set(i, ff);
}
}
}
int GetMatchLen(const String& x) const {
if(*x == '<')
return 0;
String h = PackagePath(x);
for(int i = 0; i < mainpath.GetCount(); i++)
if(mainpath[i] != h[i])
return i;
return mainpath.GetCount();
}
Vector<String> WorkspaceWork::SvnDirs(bool actual)
{
Vector<String> d = GetUppDirs();
if (actual && !IsAux())
d.Insert(0, GetFileFolder(PackagePath(actualpackage)));
Vector<String> r;
for(int i = 0; i < d.GetCount(); i++)
if(IsSvnDir(d[i]))
r.Add(d[i]);
return r;
}
void SelectPackageDlg::OnOK()
{
Package pkg;
int f = ~filter;
String n = GetCurrentName();
if(n.GetCount() && pkg.Load(PackagePath(n)) &&
(!(f & MAIN) || pkg.config.GetCount())) {
loading = false;
finished = true;
AcceptBreak(IDOK);
}
}
void SelectPackageDlg::ListCursor()
{
int c = GetCurrentIndex();
if(c >= 0 && c < packages.GetCount()) {
String pp = PackagePath(GetCurrentName());
Package pkg;
pkg.Load(pp);
description <<= pkg.description;
}
else
description <<= Null;
}
Index<String> MakeBuild::PackageConfig(const Workspace& wspc, int package,
const VectorMap<String, String>& bm, String mainparam,
Host& host, Builder& b, String *target)
{
String packagepath = PackagePath(wspc[package]);
const Package& pkg = wspc.package[package];
Index<String> cfg;
mainparam << ' ' << bm.Get(targetmode ? "RELEASE_FLAGS" : "DEBUG_FLAGS", NULL);
cfg = SplitFlags(mainparam, package == 0, wspc.GetAllAccepts(package));
cfg.FindAdd(bm.Get("BUILDER", "GCC"));
const TargetMode& m = GetTargetMode();
if(targetmode == 0)
cfg.FindAdd("DEBUG");
switch(m.linkmode) {
case 2:
cfg.FindAdd("SO");
case 1:
cfg.FindAdd("SHARED");
}
if(targetmode == 2)
cfg.FindAdd("FORCE_SPEED");
if(targetmode == 3)
cfg.FindAdd("FORCE_SIZE");
int q = m.package.Find(wspc[package]);
if(q >= 0) {
const PackageMode& p = m.package[q];
switch(p.debug >= 0 ? p.debug : m.def.debug) {
case 1: cfg.FindAdd("DEBUG_MINIMAL"); break;
case 2: cfg.FindAdd("DEBUG_FULL"); break;
}
if(!pkg.noblitz && (p.blitz >= 0 ? p.blitz : m.def.blitz))
cfg.FindAdd("BLITZ");
}
else {
switch(m.def.debug) {
case 1: cfg.FindAdd("DEBUG_MINIMAL"); break;
case 2: cfg.FindAdd("DEBUG_FULL"); break;
}
if(!pkg.noblitz && m.def.blitz)
cfg.FindAdd("BLITZ");
}
host.AddFlags(cfg);
b.AddFlags(cfg);
for(int i = 0; i < pkg.flag.GetCount(); i++) {
if(MatchWhen(pkg.flag[i].when, cfg.GetKeys()))
cfg.Add(pkg.flag[i].text);
}
if(target)
*target = Gather(pkg.target, cfg.GetKeys(), true);
return cfg;
}
void Ide::CreateMakefile()
{
const Workspace& wspc = IdeWorkspace();
if(wspc.GetCount() == 0) {
PutConsole("Project is empty!");
return;
}
FileSel mfout;
mfout.AllFilesType();
mfout <<= AppendFileName(GetFileDirectory(PackagePath(wspc[0])), "Makefile");
if(!mfout.ExecuteSaveAs("Save makefile as"))
return;
SaveMakeFile(~mfout, true);
}
void SelectPackageDlg::RenamePackage()
{
String n = GetCurrentName();
if(IsNull(n))
return;
WithRenamePackageLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, "Rename package");
dlg.name.SetFilter(FilterPackageName);
dlg.name <<= n;
dlg.name.SelectAll();
again:
if(dlg.Execute() != IDOK)
return;
if(!RenamePackageFs(PackagePath(GetCurrentName()), ~dlg.name))
goto again;
Load();
}
const Workspace& Ide::IdeWorkspace() const
{
static Workspace wspc;
static String _main;
if(main != _main || wspc.GetCount() == 0) {
wspc.Scan(main);
_main = main;
}
else {
for(int i = 0; i < wspc.GetCount(); i++)
if(wspc.GetPackage(i).time != FileGetTime(PackagePath(wspc[i]))) {
wspc.Scan(main);
break;
}
}
return wspc;
}
bool CppBuilder::Cp(const String& cmd, const String& package, bool& error) {
if(cmd.GetLength() > 2 && ToLower(cmd.Mid(0, 3)) == "cp ") {
Vector<String> path = Split(cmd.Mid(3), ' ');
if(path.GetCount() == 2) {
String p = GetFileFolder(PackagePath(package));
String p1 = NormalizePath(path[0], p);
String p2 = NormalizePath(path[1], p);
RealizePath(p2);
if(!FileExists(p1)) {
PutConsole("FAILED: " + cmd);
error = true;
}
SaveFile(p2, LoadFile(p1));
}
return true;
}
return false;
}
void SelectPackageDlg::DeletePackage()
{
String n = GetCurrentName();
if(IsNull(n))
return;
String pp = GetFileFolder(PackagePath(GetCurrentName()));
if(!DirectoryExists(pp)) {
Exclamation("Directory does not exist!");
return;
}
if(!PromptYesNo("Do you really want to delete package [* \1" + GetCurrentName() + "\1]?&&"
"[/ Warning:] [* Package will not be removed "
"from uses of any other package!]"))
return;
if(!PromptYesNo("This operation is irreversible.&Do you really want to proceed?"))
return;
DeleteFolderDeep(pp);
Load();
}
void WorkspaceWork::ScanWorkspace() {
Workspace wspc;
if(main.GetCount())
wspc.Scan(main);
actualpackage.Clear();
actualfileindex = -1;
filelist.Clear();
package.Clear();
Vector<String> pks;
speed.Clear();
for(int i = 0; i < wspc.package.GetCount(); i++) {
pks.Add(wspc.package.GetKey(i));
speed.Add(wspc.GetPackage(i).optimize_speed);
}
if(sort && wspc.GetCount()) {
PackageOrder po;
po.mainpath = PackagePath(pks[0]);
IndexSort(pks.Begin() + 1, pks.End(), speed.Begin() + 1, po);
}
for(int i = 0; i < wspc.package.GetCount(); i++) {
String pk = pks[i];
Font fnt = ListFont();
if(i == 0)
fnt.Bold();
PackageInfo pi = GetPackageInfo(pk);
if(pi.bold)
fnt.Bold();
if(pi.italic)
fnt.Italic();
package.Add(pk, Null, fnt, Nvl(pi.ink, SColorText()), false, 0, Null, SColorMark);
}
if(!organizer) {
if(main.GetCount())
package.Add(prjaux, IdeImg::PrjAux(), ListFont(), Magenta);
package.Add(ideaux, IdeImg::IdeAux(), ListFont(), Magenta);
package.Add(tempaux, IdeImg::TempAux(), ListFont(), Magenta);
if(main.GetCount())
package.Add(METAPACKAGE, IdeImg::Meta(), ListFont(), Red);
}
package.SetCursor(0);
SyncErrorPackages();
}
Vector<String> SvnInfo(const String& package)
{
Vector<String> info;
String d = GetFileFolder(PackagePath(package));
if(IsSvnDir2(d)) {
String v = Sys("svnversion " + d);
if(IsDigit(*v))
info.Add("#define bmSVN_REVISION " + AsCString(TrimBoth(v)));
v = Sys("svn info " + d);
StringStream in(v);
while(!in.IsEof()) {
String l = in.GetLine();
if(l.StartsWith("URL: ")) {
info.Add("#define bmSVN_URL " + AsCString(TrimBoth(l.Mid(5))));
break;
}
}
}
return info;
}
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 WorkspaceWork::PackageOp(String active, String from_package, String rename)
{
active = UnixPath(active);
from_package = UnixPath(from_package);
rename = UnixPath(rename);
for(int i = 0; i < package.GetCount(); i++)
if(IsNull(from_package) || UnixPath(package[i].name) == from_package) {
String pp = PackagePath(package[i].name);
RealizePath(pp);
Package prj;
prj.Load(pp);
for(int i = prj.uses.GetCount(); --i >= 0;)
if(UnixPath(prj.uses[i].text) == active) {
if(rename.GetCount())
prj.uses[i].text = rename;
else
prj.uses.Remove(i);
}
prj.Save(pp);
}
ScanWorkspace();
SyncWorkspace();
}
void SelectPackageDlg::ChangeDescription()
{
int ii = GetCurrentIndex();
if(ii >= 0 && ii < packages.GetCount()) {
PkInfo& p = packages[ii];
WithDescriptionLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, "Package description");
String pp = PackagePath(p.package);
Package pkg;
if(!pkg.Load(pp)) {
Exclamation("Package does not exist.");
return;
}
dlg.text <<= pkg.description;
if(dlg.Run() != IDOK)
return;
pkg.description = ~dlg.text;
pkg.Save(pp);
p.description = description <<= ~dlg.text;
if(alist.IsCursor())
alist.Set(2, ~dlg.text);
}
}
PackageInfo GetPackageInfo(const String& name)
{
String path = PackagePath(name);
Time tm = FileGetTime(path);
int q = sPi.Find(name);
if(q >= 0) {
if(path == sPi[q].path && tm == sPi[q].stamp)
return sPi[q];
}
else {
q = sPi.GetCount();
sPi.Add(name);
}
PackageInfo& pi = sPi[q];
pi.path = path;
pi.stamp = tm;
Package p;
p.Load(path);
pi.ink = p.ink;
pi.italic = p.italic;
pi.bold = p.bold;
return pi;
}
void WorkspaceWork::RemovePackageMenu(Bar& bar)
{
if(bar.IsScanKeys() || bar.IsScanHelp() || !bar.IsMenuBar())
return;
String active = UnixPath(GetActivePackage());
int usecnt = 0;
for(int i = 0; i < package.GetCount(); i++) {
String pn = UnixPath(package[i].name);
Package prj;
String pp = PackagePath(pn);
prj.Load(pp);
for(int i = 0; i < prj.uses.GetCount(); i++)
if(UnixPath(prj.uses[i].text) == active) {
usecnt++;
bar.Add("Remove from '" + pn + '\'', THISBACK1(RemovePackage, pn))
.Help(NFormat("Remove package '%s' from uses section in '%s'", active, pp));
}
}
if(usecnt > 1) {
bar.MenuSeparator();
bar.Add("Remove all uses", THISBACK1(RemovePackage, String(Null)))
.Help(NFormat("Remove package '%s' from all uses in active project and its submodules", active));
}
}
String WorkspaceWork::PackagePathA(const String& pn) {
if(pn == prjaux) {
String nm;
String cfg = ConfigFile("cfg");
for(const char *s = main; *s; s++)
nm.Cat(*s == '\\' || *s == '/' ? '$' : *s);
RealizeDirectory(cfg);
return AppendFileName(cfg, ForceExt(nm + '@' + GetVarsName(), ".aux"));
}
if(pn == ideaux)
return ConfigFile("ide.aux");
if(pn == tempaux)
return ConfigFile(Sprintf("aux%x.tmp",
#ifdef PLATFORM_WIN32
GetCurrentProcessId()
#endif
#ifdef PLATFORM_POSIX
getpid()
#endif
));
if(pn == METAPACKAGE)
return Null;
return PackagePath(pn);
}
bool RenamePackageFs(const String& upp, const String& newname)
{
if(IsNull(newname)) {
Exclamation("Wrong name.");
return false;
}
if(FileExists(PackagePath(newname))) {
Exclamation("Package [* \1" + newname + "\1] already exists!");
return false;
}
String pf = GetFileFolder(upp);
String npf = GetPackagePathNest(pf) + "/" + newname;
RealizePath(npf);
if(!FileMove(pf, npf)) {
Exclamation("Renaming package folder has failed.");
return false;
}
if(!FileMove(npf + "/" + GetFileName(upp), npf + "/" + GetFileName(newname) + ".upp")) {
FileMove(npf, pf);
Exclamation("Renaming .upp file has failed.");
return false;
}
return true;
}
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";
}
*/
}
String SourcePath(const String& package, const String& file) {
if(IsFullPath(file)) return NativePath(file);
return NormalizePath(AppendFileName(GetFileFolder(PackagePath(package)), file));
}
void Workspace::AddLoad(const String& name, bool match, const Vector<String>& flag)
{
package.Add(name).Load(PackagePath(name));
}
Vector<String> CppBuilder::CustomStep(const String& pf, const String& package_, bool& error)
{
String package = Nvl(package_, mainpackage);
String path = (*pf == '.' && pf[1] != '.') ? target : SourcePath(package, pf);
String file = GetHostPath(path);
String ext = ToLower(GetFileExt(pf));
if(ext == ".ext") {
Vector<String> files;
Vector<String> dirs;
sGatherAllExt(files, dirs, GetFileFolder(path), "");
Index<String> pkg_files;
Package pkg;
pkg.Load(PackagePath(package));
for(int i = 0; i < pkg.GetCount(); i++)
pkg_files.Add(pkg[i]);
Index<String> out;
Index<String> include_path;
String f = LoadFile(path);
try {
CParser p(f);
while(!p.IsEof()) {
if(p.Id("files")) {
Vector<String> e = ReadPatterns(p);
for(int i = 0; i < files.GetCount(); i++)
for(int j = 0; j < e.GetCount(); j++) {
String f = files[i];
if(PatternMatch(e[j], f) && pkg_files.Find(f) < 0)
out.FindAdd(f);
}
}
if(p.Id("exclude")) {
ExtExclude(p, out);
}
if(p.Id("include_path")) {
Vector<String> e = ReadPatterns(p);
for(int j = 0; j < e.GetCount(); j++) {
String ee = e[j];
if(ee.Find('*') >= 0)
for(int i = 0; i < dirs.GetCount(); i++) {
String d = dirs[i];
if(PatternMatch(e[j], d)) {
include_path.FindAdd(d);
}
}
else
include_path.Add(ee);
}
}
if(p.Id("exclude_path")) {
ExtExclude(p, include_path);
}
if(p.Id("includes")) {
Vector<String> e = ReadPatterns(p);
for(int i = 0; i < files.GetCount(); i++)
for(int j = 0; j < e.GetCount(); j++) {
String f = files[i];
if(PatternMatch(e[j], f) && pkg_files.Find(f) < 0)
include_path.FindAdd(GetFileFolder(f));
}
}
}
}
catch(CParser::Error) {
PutConsole("Invalid .ext file");
error = true;
return Vector<String>();
}
for(int i = 0; i < include_path.GetCount(); i++)
include.Add(NormalizePath(include_path[i], GetFileFolder(path)));
Vector<String> o;
for(int i = 0; i < out.GetCount(); i++)
o.Add(SourcePath(package, out[i]));
return o;
}
for(int i = 0; i < wspc.GetCount(); i++) {
const Array< ::CustomStep >& mv = wspc.GetPackage(i).custom;
for(int j = 0; j < mv.GetCount(); j++) {
const ::CustomStep& m = mv[j];
if(MatchWhen(m.when, config.GetKeys()) && m.MatchExt(ext)) {
VectorMap<String, String> mac;
AddPath(mac, "PATH", file);
AddPath(mac, "RELPATH", pf);
AddPath(mac, "DIR", GetFileFolder(PackagePath(package)));
AddPath(mac, "FILEDIR", GetFileFolder(file));
AddPath(mac, "PACKAGE", package);
mac.Add("FILE", GetFileName(file));
mac.Add("TITLE", GetFileTitle(file));
AddPath(mac, "EXEPATH", GetHostPath(target));
AddPath(mac, "EXEDIR", GetHostPath(GetFileFolder(target)));
mac.Add("EXEFILE", GetFileName(target));
mac.Add("EXETITLE", GetFileTitle(target));
AddPath(mac, "OUTDIR", GetHostPath(outdir));
//BW
AddPath(mac, "OUTDIR", GetHostPath(GetFileFolder(target)));
AddPath(mac, "OUTFILE", GetHostPath(GetFileName(target)));
AddPath(mac, "OUTTITLE", GetHostPath(GetFileTitle(target)));
mac.Add("INCLUDE", Join(include, ";"));
Vector<String> out = Cuprep(m.output, mac, include);
bool dirty = out.IsEmpty();
for(int i = 0; !dirty && i < out.GetCount(); i++)
dirty = (GetFileTime(file) > GetFileTime(out[i]));
if(dirty) {
HdependTimeDirty();
PutConsole(GetFileName(file));
Vector<String> cmd = Cuprep(m.command, mac, include);
String cmdtext;
for(int c = 0; c < cmd.GetCount(); c++) {
PutVerbose(cmd[c]);
if(!Cd(cmd[c]) && !Cp(cmd[c], package, error)) {
String ctext = cmd[c];
const char *cm = ctext;
if(*cm == '?')
cm++;
if(*ctext != '?' && Execute(cm)) {
for(int t = 0; t < out.GetCount(); t++)
DeleteFile(out[t]);
PutConsole("FAILED: " + ctext);
error = true;
return Vector<String>();
}
}
}
}
return out;
}
}
}
Vector<String> out;
out.Add(path);
return out;
}
void Ide::FindInFiles(bool replace) {
CodeEditor::FindReplaceData d = editor.GetFindReplaceData();
CtrlRetriever rf;
rf(ff.find, d.find)
(ff.replace, d.replace)
(ff.ignorecase, d.ignorecase)
(ff.samecase, d.samecase)
(ff.wholeword, d.wholeword)
(ff.wildcards, d.wildcards)
(ff.regexp, d.regexp)
;
WriteList(ff.find, d.find_list);
WriteList(ff.replace, d.replace_list);
ff.Sync();
if(IsNull(~ff.folder))
ff.folder <<= GetUppDir();
ff.style <<= STYLE_NO_REPLACE;
ff.Sync();
ff.itext = editor.GetI();
ff.Setup(replace);
int c = ff.Execute();
ff.find.AddHistory();
ff.replace.AddHistory();
rf.Retrieve();
d.find_list = ReadList(ff.find);
d.replace_list = ReadList(ff.replace);
editor.SetFindReplaceData(d);
if(c == IDOK) {
ffound.HeaderTab(2).SetText("Source line");
Renumber();
ff.find.AddHistory();
ff.files.AddHistory();
ff.folder.AddHistory();
ff.replace.AddHistory();
Progress pi("Found %d files to search.");
pi.AlignText(ALIGN_LEFT);
Index<String> files;
if(ff.workspace) {
const Workspace& wspc = GetIdeWorkspace();
for(int i = 0; i < wspc.GetCount(); i++)
SearchForFiles(files, GetFileFolder(PackagePath(wspc[i])),
~ff.files, ~ff.readonly, pi);
}
else
SearchForFiles(files, NormalizePath(~~ff.folder, GetUppDir()), ~ff.files, ~ff.readonly, pi);
if(!pi.Canceled()) {
String pattern;
RegExp rx, *regexp = NULL;
if(ff.regexp) {
rx.SetPattern(~ff.find);
regexp = ℞
pattern = "dummy";
}
else
if(ff.wildcards) {
String q = ~ff.find;
for(const char *s = q; *s; s++)
if(*s == '\\') {
s++;
if(*s == '\0') break;
pattern.Cat(*s);
}
else
switch(*s) {
case '*': pattern.Cat(WILDANY); break;
case '?': pattern.Cat(WILDONE); break;
case '%': pattern.Cat(WILDSPACE); break;
case '#': pattern.Cat(WILDNUMBER); break;
case '$': pattern.Cat(WILDID); break;
default: pattern.Cat(*s);
}
}
else
pattern = ~ff.find;
pi.SetTotal(files.GetCount());
ShowConsole2();
ffound.Clear();
pi.SetPos(0);
int n = 0;
for(int i = 0; i < files.GetCount(); i++) {
pi.SetText(files[i]);
if(pi.StepCanceled()) break;
if(!IsNull(pattern)) {
if(!SearchInFile(files[i], pattern, ff.wholeword, ff.ignorecase, n, regexp))
break;
}
else {
ErrorInfo f;
f.file = files[i];
f.lineno = 1;
f.linepos = 0;
f.kind = 0;
f.message = files[i];
ffound.Add(f.file, 1, f.message, RawToValue(f));
ffound.Sync();
n++;
}
}
if(!IsNull(pattern))
ffound.Add(Null, Null, AsString(n) + " occurrence(s) have been found.");
else
ffound.Add(Null, Null, AsString(n) + " matching file(s) have been found.");
ffound.HeaderTab(2).SetText(Format("Source line (%d)", ffound.GetCount()));
}
}
}
