wxString CompilerMINGWGenerator::SetupIncludeDirs(Compiler* compiler, ProjectBuildTarget* target)
{
wxString result = CompilerCommandGenerator::SetupIncludeDirs(compiler, target);
m_VerStr = compiler->GetVersionString();
wxString pch_prepend = wxEmptyString;
long gcc_major = 4;
if ( !m_VerStr.IsEmpty() )
m_VerStr.BeforeFirst('.').ToLong(&gcc_major);
bool HasPCH = false; // We don't know yet if there are any header files to be compiled...
// for PCH to work, the very first include dir *must* be the object output dir
// *only* if PCH is generated in the object output dir
if (target &&
target->GetParentProject()->GetModeForPCH() == pchObjectDir)
{
wxArrayString includedDirs; // avoid adding duplicate dirs...
wxString sep = wxFILE_SEP_PATH;
// find all PCH in project
for (FilesList::iterator it = target->GetParentProject()->GetFilesList().begin(); it != target->GetParentProject()->GetFilesList().end(); ++it)
{
ProjectFile* f = *it;
if (FileTypeOf(f->relativeFilename) == ftHeader &&
f->compile)
{
// it is a PCH; add it's object dir to includes
wxFileName fn(f->GetObjName());
wxString objName = (compiler->GetSwitches().UseFlatObjects) ? fn.GetFullName() : fn.GetFullPath();
wxString dir = wxFileName(target->GetObjectOutput() + sep + objName).GetPath();
if (includedDirs.Index(dir) == wxNOT_FOUND)
{
includedDirs.Add(dir);
QuoteStringIfNeeded(dir);
if ( gcc_major < 4 )
pch_prepend << compiler->GetSwitches().includeDirs << dir << _T(' ');
else
pch_prepend << _T("-iquote") << dir << _T(' ');
}
HasPCH = true; // there is at least one header file to be compiled
}
}
// for gcc-4.0+, use the following:
// pch_prepend << _T("-iquote") << dir << _T(' ');
// for earlier versions, -I- must be used
if ( gcc_major < 4 )
pch_prepend << _T("-I- ");
int count = (int)includedDirs.GetCount();
for (int i = 0; i < count; ++i)
{
QuoteStringIfNeeded(includedDirs[i]);
pch_prepend << compiler->GetSwitches().includeDirs << includedDirs[i] << _T(' ');
}
pch_prepend << _T("-I. ");
}
// add in array
if (HasPCH)
result.Prepend(pch_prepend);
return result;
}
void pfDetails::Update(ProjectBuildTarget* target, ProjectFile* pf)
{
wxString sep = wxFILE_SEP_PATH;
wxFileName tmp;
wxFileName prjbase(target->GetParentProject()->GetBasePath());
wxString objOut = target ? target->GetObjectOutput() : _T(".");
wxString depsOut = target ? target->GetDepsOutput() : _T(".");
// we must replace any macros here early because if the macros expand
// to absolute paths (like global vars usually do), we 're gonna create
// invalid filenames below
Manager::Get()->GetMacrosManager()->ReplaceMacros(objOut, target);
Manager::Get()->GetMacrosManager()->ReplaceMacros(depsOut, target);
source_file_native = pf->relativeFilename;
source_file_absolute_native = pf->file.GetFullPath();
tmp = pf->GetObjName();
FileType ft = FileTypeOf(pf->relativeFilename);
Compiler* compiler = target
? CompilerFactory::GetCompiler(target->GetCompilerID())
: CompilerFactory::GetDefaultCompiler();
// support for precompiled headers
if (target && ft == ftHeader && compiler && compiler->GetSwitches().supportsPCH)
{
switch (target->GetParentProject()->GetModeForPCH())
{
case pchSourceDir:
{
// if PCH is for a file called all.h, we create
// all.h.gch/<target>_all.h.gch
// (that's right: a directory)
wxString new_gch = target->GetTitle() + _T('_') + pf->GetObjName();
// make sure we 're not generating subdirs
size_t len = new_gch.Length();
for (size_t i = 0; i < len; ++i)
{
wxChar c = new_gch[i];
if (c == _T('/') || c == _T('\\') || c == _T('.'))
new_gch[i] = _T('_');
}
wxFileName fn(source_file_native);
object_file_native = fn.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR) +
fn.GetName() + _T('.') + compiler->GetSwitches().PCHExtension +
wxFILE_SEP_PATH +
new_gch;
object_file_flat_native = object_file_native;
break;
}
case pchObjectDir:
{
object_file_native = objOut + sep + tmp.GetFullPath();
object_file_flat_native = objOut + sep + tmp.GetFullName();
break;
}
case pchSourceFile:
{
object_file_native = pf->GetObjName();
object_file_flat_native = object_file_native;
break;
}
}
}
else
{
if (pf->GetParentProject())
{
wxFileName fname(pf->relativeToCommonTopLevelPath);
if (pf->generatedFiles.size())
{
// for files generating other files,
// use the first generated file's "object name"
fname.Assign(pf->generatedFiles[0]->relativeToCommonTopLevelPath);
}
/* NOTE: In case the source file resides in a different volume
* than the volume where project file is,
* then the object file will be created as follows.
*
* Project object output dir: C:\Foo\obj\Debug
* Source: D:\Source\foo.cpp
* Obj file: C:\Foo\obj\Debug\D\Source\foo.o
*/
wxString fileVol = fname.GetVolume();
wxString obj_file_full_path = fname.GetFullPath();
bool diffVolume = false;
if (platform::windows
&& (!fileVol.IsEmpty() && !fileVol.IsSameAs(prjbase.GetVolume())))
{
objOut += fileVol;
obj_file_full_path = obj_file_full_path.AfterFirst(_T('\\'));
diffVolume = true;
}
if (ft == ftResource || ft == ftResourceBin)
{
if (pf->GetParentProject()->GetExtendedObjectNamesGeneration())
{
object_file_native = objOut + sep + obj_file_full_path;
object_file_flat_native = objOut + sep + fname.GetFullName();
object_file_native += FileFilters::RESOURCEBIN_DOT_EXT;
object_file_flat_native += FileFilters::RESOURCEBIN_DOT_EXT;
}
else
{
fname.SetExt(FileFilters::RESOURCEBIN_EXT);
wxString obj_file_path = fname.GetFullPath();
if (diffVolume)
obj_file_path = obj_file_path.AfterFirst(_T('\\'));
object_file_native = objOut + sep + obj_file_path;
object_file_flat_native = objOut + sep + fname.GetFullName();
}
}
else
{
if (pf->GetParentProject()->GetExtendedObjectNamesGeneration())
{
object_file_native = objOut + sep + obj_file_full_path;
object_file_flat_native = objOut + sep + fname.GetFullName();
if (compiler)
{
object_file_native += _T('.') + compiler->GetSwitches().objectExtension;
object_file_flat_native += _T('.') + compiler->GetSwitches().objectExtension;
}
}
else
{
if (compiler)
fname.SetExt(compiler->GetSwitches().objectExtension);
wxString obj_file_path = fname.GetFullPath();
if (diffVolume)
obj_file_path = obj_file_path.AfterFirst(_T('\\'));
object_file_native = objOut + sep + obj_file_path;
object_file_flat_native = objOut + sep + fname.GetFullName();
}
}
}
}
wxFileName o_file(object_file_native);
wxFileName o_file_flat(object_file_flat_native);
o_file.MakeAbsolute(prjbase.GetFullPath());
o_file_flat.MakeAbsolute(prjbase.GetFullPath());
object_dir_native = o_file.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
object_dir_flat_native = o_file_flat.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
object_file_absolute_native = o_file.GetFullPath();
object_file_flat_absolute_native = o_file_flat.GetFullPath();
tmp.SetExt(_T("depend"));
dep_file_native = depsOut + sep + tmp.GetFullPath();
wxFileName d_file(dep_file_native);
d_file.MakeAbsolute(prjbase.GetFullPath());
dep_dir_native = d_file.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
dep_file_absolute_native = o_file.GetFullPath();
source_file = UnixFilename(source_file_native);
QuoteStringIfNeeded(source_file);
object_file = UnixFilename(object_file_native);
QuoteStringIfNeeded(object_file);
object_file_flat = UnixFilename(object_file_flat_native);
QuoteStringIfNeeded(object_file_flat);
dep_file = UnixFilename(dep_file_native);
QuoteStringIfNeeded(dep_file);
object_dir = UnixFilename(object_dir_native);
QuoteStringIfNeeded(object_dir);
object_dir_flat = UnixFilename(object_dir_flat_native);
QuoteStringIfNeeded(object_dir_flat);
dep_dir = UnixFilename(dep_dir_native);
QuoteStringIfNeeded(dep_dir);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file_flat_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_dir_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_dir_flat_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file_absolute_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file_flat_absolute_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(dep_file_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(dep_dir_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(dep_file_absolute_native);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(dep_dir);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_dir);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_dir_flat);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(dep_file);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(object_file_flat);
Manager::Get()->GetMacrosManager()->ReplaceEnvVars(source_file);
}
bool cbMGMakefile::reLoadDependecies(const wxString &p_DepsFileName,ProjectBuildTarget *p_pTarget,Compiler* p_pCompiler)
{
m_Deps.Clear();
if ( !wxFileExists( p_DepsFileName ) ) return false;
wxString l_Buf;
wxString l_VarName;
wxTextFile l_DepFile;
bool IsSkipThisFile = true;
if (l_DepFile.Open( p_DepsFileName, wxConvFile ))
{
for ( unsigned long i = 0; i < l_DepFile.GetLineCount(); i++ )
{
l_Buf = l_DepFile[i];
l_Buf.Trim(true);
// Wrong! Don't uncomment it! Being deleted '\t' symbol! l_Buf.Trim(false);
if ( l_Buf.IsEmpty() )
{
l_VarName.Clear();
IsSkipThisFile = true;
continue;
}
if ( _T('#') == l_Buf[0] ) continue;
if ( _T('\t') == l_Buf[0] )
{
if ( !IsSkipThisFile )
{
if ( _T('"') == l_Buf[1] )
{
wxString l_TmpName = l_Buf.AfterFirst( _T('\t') );
if (!l_TmpName.IsEmpty() && l_TmpName.GetChar(0) == _T('"') && l_TmpName.Last() == _T('"'))
l_TmpName = l_TmpName.Mid(1, l_TmpName.Length() - 2);
QuoteStringIfNeeded( l_TmpName );
m_Deps.AppendValue( l_VarName, l_TmpName );
}
}
}
else
{
l_VarName = l_Buf.AfterFirst(_T(' '));
bool IsSource = l_VarName.Matches( _T("source:*") );
if ( IsSource )
{
l_VarName = l_VarName.AfterFirst( _T(':') );
}
/*
* You would MUST found source file and get his filename from project
* !!! .depend file content lowcase filenames
*/
wxFileName l_DepFileName = l_VarName;
ProjectFile *pf = m_pProj->GetFileByFilename( l_DepFileName.GetFullPath(), l_DepFileName.IsRelative(), false );
if ( pf )
{
const pfDetails& pfd = pf->GetFileDetails( p_pTarget );
if ( p_pCompiler->GetSwitches().UseFullSourcePaths )
{
l_VarName = UnixFilename( pfd.source_file_absolute_native );
}
else
{
l_VarName = pfd.source_file;
}
QuoteStringIfNeeded( l_VarName );
IsSkipThisFile = false;
}
else
{
IsSkipThisFile = true;
}
}
}
}
/* FIXME (kisoftcb#1#): Next code for debug only!
wxTextFile l_DebFile;
l_DebFile.Create( _T("D:/DepsFile.log") );
m_Deps.SaveAllVars( l_DebFile );
l_DebFile.Write();
l_DebFile.Close(); */
}
bool cbMGMakefile::SaveMakefile()
{
bool l_Ret = false;
wxString l_FullFilename = m_Path + m_Filename;
if ( m_Overwrite && wxFileExists( l_FullFilename ) ) wxRemoveFile( l_FullFilename );
wxTextFile l_File;
if ( !l_File.Create( l_FullFilename ) )
{
wxString lMsg = _( "File " ) + l_FullFilename + _(" is exists!\nOverwrite?" );
if (wxID_YES == cbMessageBox(lMsg, _("Warning"), wxICON_EXCLAMATION | wxYES_NO, (wxWindow *)Manager::Get()->GetAppWindow()))
{
wxRemoveFile( l_FullFilename );
}
else
{
return l_Ret;
}
}
// for active target only!
wxString l_ActiveTargetName = m_pProj->GetActiveBuildTarget();
ProjectBuildTarget* l_pTarget = m_pProj->GetBuildTarget( l_ActiveTargetName );
if ( !l_pTarget )
{
wxString l_Msg = _( "Can't found an active target!\n"
"C::B MakefileGen could not complete the operation." );
cbMessageBox( l_Msg, _( "Error" ), wxICON_ERROR | wxOK, (wxWindow *)Manager::Get()->GetAppWindow() );
Manager::Get()->GetMessageManager()->DebugLog( l_Msg );
return l_Ret;
}
const wxString& l_CompilerId = l_pTarget->GetCompilerID();
Compiler* l_pCompiler = CompilerFactory::GetCompiler( l_CompilerId );
if ( !getDependencies( l_pTarget, l_pCompiler ) ) return false;
m_Variables.AddVariable(_T("CPP"),l_pCompiler->GetPrograms().CPP);
m_Variables.AddVariable(_T("CC"),l_pCompiler->GetPrograms().C);
m_Variables.AddVariable(_T("LD"),l_pCompiler->GetPrograms().LD);
m_Variables.AddVariable(_T("LIB"),l_pCompiler->GetPrograms().LIB);
m_Variables.AddVariable(_T("WINDRES"),l_pCompiler->GetPrograms().WINDRES);
const wxArrayString& l_CommandsBeforeBuild = l_pTarget->GetCommandsBeforeBuild();
const wxArrayString& l_CommandsAfterBuild = l_pTarget->GetCommandsAfterBuild();
wxString l_TargetFileName = l_pTarget->GetOutputFilename();
Manager::Get()->GetMacrosManager()->ReplaceMacros(l_TargetFileName, l_pTarget);
wxFileName l_OutFileName = UnixFilename(l_TargetFileName);
cbMGRule l_Rule;
if ( 0 == l_ActiveTargetName.CmpNoCase( _T( "default" ) ) )
{
l_Rule.SetTarget( _T( "all" ) );
}
else
{
l_Rule.SetTarget( l_ActiveTargetName );
}
wxString l_Pre;
if ( l_CommandsBeforeBuild.GetCount() > 0 )
{
l_Pre = cmdbefore + _T(" ");
}
l_Pre += l_OutFileName.GetFullPath();
if ( l_CommandsAfterBuild.GetCount() > 0 )
{
l_Pre += _T(" ") + cmdafter;
}
l_Rule.SetPrerequisites( l_Pre );
m_Rules.Add( l_Rule );
if ( l_CommandsBeforeBuild.GetCount() > 0 )
{
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( cmdbefore );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( cmdbefore );
for ( unsigned long idx = 0; idx < l_CommandsBeforeBuild.GetCount(); idx ++ )
{
l_Rule.AddCommand( l_CommandsBeforeBuild[ idx ] );
}
m_Rules.Add( l_Rule );
}
if ( l_CommandsAfterBuild.GetCount() > 0 )
{
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( cmdafter );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( cmdafter );
for ( unsigned long idx = 0; idx < l_CommandsAfterBuild.GetCount(); idx ++ )
{
l_Rule.AddCommand( l_CommandsAfterBuild[ idx ] );
}
m_Rules.Add( l_Rule );
}
l_Rule.Clear();
l_Rule.SetTarget( l_OutFileName.GetFullPath() );
l_Rule.SetPrerequisites( objs );
wxString kind_of_output = _T( "unknown" );
CommandType ct = ctInvalid; // get rid of compiler warning
switch ( l_pTarget->GetTargetType() )
{
case ttConsoleOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _T( "console executable" );
break;
case ttExecutable:
ct = ctLinkExeCmd;
kind_of_output = _T( "executable" );
break;
case ttDynamicLib:
ct = ctLinkDynamicCmd;
kind_of_output = _T( "dynamic library" );
break;
case ttStaticLib:
ct = ctLinkStaticCmd;
kind_of_output = _T( "static library" );
break;
case ttNative:
ct = ctLinkNativeCmd;
kind_of_output = _T( "native" );
break;
case ttCommandsOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _T( "commands only" );
break;
// case ttCommandsOnly:
// // add target post-build commands
// ret.Clear();
// AppendArray(GetPostBuildCommands(target), ret);
// return ret;
// break;
break;
}
/*if(ttCommandsOnly == lTarget->GetTargetType())
{
GetPostBuildCommands(lTarget);
}
else*/
{
l_Rule.AddCommand( _T( "echo Building " ) + kind_of_output + _T( " " ) + l_OutFileName.GetFullPath() );
wxString l_LinkerCmd = l_pCompiler->GetCommand( ct );
l_pCompiler->GenerateCommandLine( l_LinkerCmd,
l_pTarget,
NULL,
l_OutFileName.GetFullPath(),
oobjs,
wxEmptyString,
wxEmptyString );
l_Rule.AddCommand( l_LinkerCmd );
}
m_Rules.Add( l_Rule );
// Form rules
wxString l_Tmp;
unsigned long ii;
wxString macro;
wxString file;
wxString object;
wxString FlatObject;
wxString deps;
cbMGSortFilesArray files = GetProjectFilesSortedByWeight(l_pTarget,true,false);
unsigned long lnb_files = files.GetCount();
for ( ii = 0; ii < lnb_files; ii++ )
{
l_Rule.Clear();
ProjectFile* pf = files[ ii ];
const pfDetails& pfd = pf->GetFileDetails( l_pTarget );
wxString l_Object = ( l_pCompiler->GetSwitches().UseFlatObjects )?pfd.object_file_flat:pfd.object_file;
wxString l_CompilerCmd;
// lookup file's type
FileType ft = FileTypeOf( pf->relativeFilename );
bool isResource = ft == ftResource;
bool isHeader = ft == ftHeader;
if ( !isHeader || l_pCompiler->GetSwitches().supportsPCH )
{
pfCustomBuild& pcfb = pf->customBuild[l_pCompiler->GetID()];
l_CompilerCmd = pcfb.useCustomBuildCommand
? pcfb.buildCommand
: l_pCompiler->GetCommand( isResource ? ctCompileResourceCmd : ctCompileObjectCmd );
wxString l_SourceFile;
if ( l_pCompiler->GetSwitches().UseFullSourcePaths )
{
l_SourceFile = UnixFilename( pfd.source_file_absolute_native );
// for resource files, use short from if path because if windres bug with spaces-in-paths
if ( isResource )
{
l_SourceFile = pf->file.GetShortPath();
}
}
else
{
l_SourceFile = pfd.source_file;
}
QuoteStringIfNeeded( l_SourceFile );
l_pCompiler->GenerateCommandLine( l_CompilerCmd,
l_pTarget,
pf,
l_SourceFile,
l_Object,
pfd.object_file_flat,
pfd.dep_file );
m_Variables.AppendValue( _T( "OBJS" ), l_Object );
l_Rule.SetTarget( l_Object );
l_Rule.SetPrerequisites( l_SourceFile );
l_Rule.AddCommand( _T( "echo Compiling: " ) + l_SourceFile );
l_Rule.AddCommand( l_CompilerCmd );
m_Rules.Add( l_Rule );
}
}
for ( unsigned long i=0; i < m_Deps.Count(); i++ )
{
l_Rule.Clear();
l_Rule.SetTarget( m_Deps.GetVarName( i ) );
l_Rule.SetPrerequisites( m_Deps.GetVariable( i ) );
m_Rules.Add( l_Rule );
}
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( cmdclean );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( cmdclean );
l_Rule.AddCommand( _T( "echo Delete $(OBJS) " ) + l_OutFileName.GetFullPath() );
#ifdef __WXMSW__
l_Rule.AddCommand( _T( "del /f $(OBJS) " ) + l_OutFileName.GetFullPath() );
#else
l_Rule.AddCommand( _T( "rm -f $(OBJS) " ) + l_OutFileName.GetFullPath() );
#endif
m_Rules.Add( l_Rule );
// save header
l_File.AddLine( sHeader );
l_File.AddLine( wxEmptyString );
m_Variables.SaveAllVars( l_File );
SaveAllRules( l_File );
l_File.Write();
l_File.Close();
l_Ret = true;
return l_Ret;
}
/// This is to be used *only* for files not belonging to a project!!!
wxArrayString DirectCommands::GetCompileSingleFileCommand(const wxString& filename)
{
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();
// if(m_pCompiler->GetName().Matches(_T("dsp"))) /// 2012-8-27 lcy
// fname.SetExt(FileFilters::DSP563_EXT);
// else if(m_pCompiler->GetName().Matches(_T("mc")))
// fname.SetExt(FileFilters::OR32_EXT);
// else
fname.SetExt(FileFilters::EXECUTABLE_EXT);
wxString exe_filename = fname.GetFullPath();
wxString s_filename = filename;
QuoteStringIfNeeded(s_filename);
QuoteStringIfNeeded(o_filename);
Compiler* compiler = CompilerFactory::GetDefaultCompiler();
wxString compilerCmd = compiler->GetCommand(ctCompileObjectCmd, srcExt);
compiler->GenerateCommandLine(compilerCmd,
0,
0,
s_filename,
o_filename,
o_filename,
wxEmptyString);
wxString linkerCmd = compiler->GetCommand(ctLinkConsoleExeCmd, fname.GetExt());
compiler->GenerateCommandLine(linkerCmd,
0,
0,
wxEmptyString,
o_filename,
o_filename,
wxEmptyString);
// wxString asmCmd = compiler->GetCommand(ctCompileAsmCmd, _T("asm")); /// 2012-8-27 lcy
// compiler->GenerateCommandLine(asmCmd,
// 0,
// 0,
// wxEmptyString,
// o_filename,
// o_filename,
// wxEmptyString);
if (!compilerCmd.IsEmpty()) // my 2
{
switch (m_pCompiler->GetSwitches().logging)
{
case clogFull:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + compilerCmd);
break;
case clogSimple:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Compiling: ") + filename);
break;
default:
break;
}
AddCommandsToArray(compilerCmd, ret);
}
else
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Skipping file (no compiler program set): ") + filename);
if (!linkerCmd.IsEmpty())
{
switch (m_pCompiler->GetSwitches().logging)
{
case clogFull:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + linkerCmd);
break;
default:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Linking console executable: ") + exe_filename);
break;
}
AddCommandsToArray(linkerCmd, ret, true);
}
else
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Skipping linking (no linker program set): ") + exe_filename);
// if (!asmCmd.IsEmpty())
// {
// switch (m_pCompiler->GetSwitches().logging)
// {
// case clogFull:
// ret.Add(wxString(COMPILER_SIMPLE_LOG) + asmCmd);
// break;
//
// default:
// ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Linking console executable: ") + exe_filename);
// break;
// }
// AddCommandsToArray(asmCmd, ret, true);
// }
// else
// ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Skipping linking (no linker program set): ") + exe_filename);
return ret;
}
wxArrayString DirectCommands::GetCompileFileCommand(ProjectBuildTarget* target, ProjectFile* pf)
{
wxArrayString ret;
wxArrayString retGenerated;
// is it compilable?
if (!pf->compile || pf->compilerVar.IsEmpty())
return ret;
const pfDetails& pfd = pf->GetFileDetails(target);
Compiler* compiler = target ? CompilerFactory::GetCompiler(target->GetCompilerID()) : m_pCompiler;
// wxString Object = (compiler->GetSwitches().UseFlatObjects)?pfd.object_file_flat:pfd.object_file;
wxString Object = (target->GetUseFlatObjects())?pfd.object_file_flat:pfd.object_file;
// lookup file's type
FileType ft = FileTypeOf(pf->relativeFilename);
// create output dir
if (!pfd.object_dir_native.IsEmpty() && !CreateDirRecursively(pfd.object_dir_native, 0755))
{
cbMessageBox(_("Can't create object output directory ") + pfd.object_dir_native);
}
bool isResource = ft == ftResource;
bool isHeader = ft == ftHeader;
// allowed resources under all platforms: makes sense when cross-compiling for
// windows under linux.
// and anyway, if the user is dumb enough to try to compile resources without
// having a resource compiler, (s)he deserves the upcoming build error ;)
//#ifndef __WXMSW__
// // not supported under non-win32 platforms
// if (isResource)
// return ret;
//#endif
wxString compilerCmd,source_file,tempCompilerCmd(wxEmptyString);
if (!isHeader || compiler->GetSwitches().supportsPCH)
{
const CompilerTool& tool = compiler->GetCompilerTool(isResource ? ctCompileResourceCmd : ctCompileObjectCmd, pf->file.GetExt());
// does it generate other files to compile?
for (size_t i = 0; i < pf->generatedFiles.size(); ++i)
{
AppendArray(GetCompileFileCommand(target, pf->generatedFiles[i]), retGenerated); // recurse
}
pfCustomBuild& pcfb = pf->customBuild[compiler->GetID()];
compilerCmd = pcfb.useCustomBuildCommand
? pcfb.buildCommand
: tool.command;
if (target->GetUseFullSourcePaths())
{
source_file = UnixFilename(pfd.source_file_absolute_native);
// for resource files, use short from if path because if windres bug with spaces-in-paths
if (isResource)
source_file = pf->file.GetShortPath();
}
else
source_file = pfd.source_file;
QuoteStringIfNeeded(source_file);
compiler->GenerateCommandLine(compilerCmd,
target,
pf,
source_file,
Object,
pfd.object_file_flat,
pfd.dep_file);
}
if (!compilerCmd.IsEmpty()) // my lcy 1
{
switch (compiler->GetSwitches().logging)
{
case clogFull:
ret.Add(wxString(COMPILER_SIMPLE_LOG) + compilerCmd);
break;
case clogSimple:
if (isHeader)
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Precompiling header: ") + pfd.source_file_native);
else
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Compiling: ") + pfd.source_file_native);
break;
default:
break;
}
AddCommandsToArray(compilerCmd, ret);
if(m_pCurrTarget->GetGenerateEachLit())
AddCommandsToArray(GenerateLitForEachObj(Object,compiler->GetPrograms().OBJDUMP),ret);
if (isHeader)
ret.Add(wxString(COMPILER_WAIT));
if (retGenerated.GetCount())
{
// not only append commands for (any) generated files to be compiled
// but also insert a "pause" to allow this file to generate its files first
if (!isHeader) // if isHeader, the "pause" has already been added
ret.Add(wxString(COMPILER_WAIT));
AppendArray(retGenerated, ret);
}
// if it's a PCH, delete the previously generated PCH to avoid problems
// (it 'll be recreated anyway)
if (FileTypeOf(pf->relativeFilename) == ftHeader && pf->compile)
{
wxString ObjectAbs = (m_pCurrTarget->GetUseFlatObjects())?pfd.object_file_flat_absolute_native:pfd.object_file_absolute_native;
wxRemoveFile(ObjectAbs);
}
}
else // lcy skip
{
ret.Add(wxString(COMPILER_SIMPLE_LOG) + _("Skipping file (no compiler program set): ") + pfd.source_file_native);
}
return ret;
}
/// 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;
}
wxArrayString DirectCommands::GetCompileFileCommand(ProjectBuildTarget* target, ProjectFile* pf) const
{
wxArrayString ret;
wxArrayString ret_generated;
// is it compilable?
if (!pf || !pf->compile)
return ret;
if (pf->compilerVar.IsEmpty())
{
Manager::Get()->GetLogManager()->DebugLog(_("Cannot resolve compiler var for project file."));
return ret;
}
Compiler* compiler = target
? CompilerFactory::GetCompiler(target->GetCompilerID())
: m_pCompiler;
if (!compiler)
{
Manager::Get()->GetLogManager()->DebugLog(_("Can't access compiler for file."));
return ret;
}
const pfDetails& pfd = pf->GetFileDetails(target);
wxString object = (compiler->GetSwitches().UseFlatObjects)
? pfd.object_file_flat : pfd.object_file;
wxString object_dir = (compiler->GetSwitches().UseFlatObjects)
? pfd.object_dir_flat_native : pfd.object_dir_native;
// create output dir
if (!object_dir.IsEmpty() && !CreateDirRecursively(object_dir, 0755))
Manager::Get()->GetLogManager()->DebugLog(_("Can't create object output directory:\n") + object_dir);
// lookup file's type
const FileType ft = FileTypeOf(pf->relativeFilename);
bool is_resource = ft == ftResource;
bool is_header = ft == ftHeader;
// allowed resources under all platforms: makes sense when cross-compiling for
// windows under linux.
// and anyway, if the user is dumb enough to try to compile resources without
// having a resource compiler, (s)he deserves the upcoming build error ;)
wxString compiler_cmd;
if (!is_header || compiler->GetSwitches().supportsPCH)
{
const CompilerTool* tool = compiler->GetCompilerTool(is_resource ? ctCompileResourceCmd : ctCompileObjectCmd, pf->file.GetExt());
// does it generate other files to compile?
for (size_t i = 0; i < pf->generatedFiles.size(); ++i)
AppendArray(GetCompileFileCommand(target, pf->generatedFiles[i]), ret_generated); // recurse
pfCustomBuild& pcfb = pf->customBuild[compiler->GetID()];
if (pcfb.useCustomBuildCommand)
compiler_cmd = pcfb.buildCommand;
else if (tool)
compiler_cmd = tool->command;
else
compiler_cmd = wxEmptyString;
wxString source_file;
if (compiler->GetSwitches().UseFullSourcePaths)
source_file = UnixFilename(pfd.source_file_absolute_native);
else
source_file = pfd.source_file;
#ifdef command_line_generation
Manager::Get()->GetLogManager()->DebugLog(F(_T("GetCompileFileCommand[1]: compiler_cmd='%s', source_file='%s', object='%s', object_dir='%s'."),
compiler_cmd.wx_str(), source_file.wx_str(), object.wx_str(), object_dir.wx_str()));
#endif
// for resource files, use short from if path because if windres bug with spaces-in-paths
if (is_resource && compiler->GetSwitches().UseFullSourcePaths)
source_file = pf->file.GetShortPath();
QuoteStringIfNeeded(source_file);
#ifdef command_line_generation
Manager::Get()->GetLogManager()->DebugLog(F(_T("GetCompileFileCommand[2]: source_file='%s'."),
source_file.wx_str()));
#endif
m_pGenerator->GenerateCommandLine(compiler_cmd,
target,
pf,
source_file,
object,
pfd.object_file_flat,
pfd.dep_file);
}
if (!is_header && compiler_cmd.IsEmpty())
{
ret.Add(COMPILER_SIMPLE_LOG + _("Skipping file (no compiler program set): ") + pfd.source_file_native );
return ret;
}
switch (compiler->GetSwitches().logging)
{
case clogFull:
ret.Add(COMPILER_SIMPLE_LOG + compiler_cmd);
break;
case clogSimple:
if (is_header)
ret.Add(COMPILER_SIMPLE_LOG + _("Pre-compiling header: ") + pfd.source_file_native );
else
ret.Add(COMPILER_SIMPLE_LOG + _("Compiling: ") + pfd.source_file_native );
break;
case clogNone: // fall-through
default:
break;
}
AddCommandsToArray(compiler_cmd, ret);
if (is_header)
ret.Add(COMPILER_WAIT);
if (ret_generated.GetCount())
{
// not only append commands for (any) generated files to be compiled
// but also insert a "pause" to allow this file to generate its files first
if (!is_header) // if is_header, the "pause" has already been added
ret.Add(COMPILER_WAIT);
AppendArray(ret_generated, ret);
}
// if it's a PCH, delete the previously generated PCH to avoid problems
// (it 'll be recreated anyway)
if ( (ft == ftHeader) && pf->compile )
{
wxString object_abs = (compiler->GetSwitches().UseFlatObjects)
? pfd.object_file_flat_absolute_native
: pfd.object_file_absolute_native;
if ( wxFileExists(object_abs) && !wxRemoveFile(object_abs) )
Manager::Get()->GetLogManager()->DebugLog(_("Cannot remove old PCH file:\n") + object_abs);
}
return ret;
}
bool cbMGMakefile::formFileForTarget( ProjectBuildTarget *p_BuildTarget, wxTextFile &p_File )
{
bool l_Ret = false;
if ( !p_BuildTarget )
{
wxString l_Msg = _( "Can't found an active target!\n"
"C::B MakefileGen could not complete the operation." );
cbMessageBox( l_Msg, _( "Error" ), wxICON_ERROR | wxOK, (wxWindow *)Manager::Get()->GetAppWindow() );
Manager::Get()->GetLogManager()->DebugLog( l_Msg );
return l_Ret;
}
wxString l_TargetName = p_BuildTarget->GetTitle();
l_TargetName.Replace( _T( " " ), _T( "_" ) );
wxString l_ObjsName = _T("OBJS_") + l_TargetName.Upper();
wxString l_CmdBefore = cmdbefore + _T('_') + l_TargetName;
wxString l_CmdAfter = cmdafter + _T('_') + l_TargetName;
wxString l_CmdClean = cmdclean + _T('_') + l_TargetName;
m_Rules.Clear();
const wxString& l_CompilerId = p_BuildTarget->GetCompilerID();
Compiler* l_pCompiler = CompilerFactory::GetCompiler( l_CompilerId );
if( !l_pCompiler )
{
wxString l_Msg = _( "Can't found an compiler settings!\n"
"C::B MakefileGen could not complete the operation." );
cbMessageBox( l_Msg, _( "Error" ), wxICON_ERROR | wxOK, (wxWindow *)Manager::Get()->GetAppWindow() );
Manager::Get()->GetLogManager()->DebugLog( l_Msg );
return false;
}
if ( !getDependencies( p_BuildTarget, l_pCompiler ) ) return false;
if ( !m_VariablesIsSaved )
{
m_Variables.AddVariable(_T("CPP"),l_pCompiler->GetPrograms().CPP);
m_Variables.AddVariable(_T("CC"),l_pCompiler->GetPrograms().C);
m_Variables.AddVariable(_T("LD"),l_pCompiler->GetPrograms().LD);
m_Variables.AddVariable(_T("LIB"),l_pCompiler->GetPrograms().LIB);
m_Variables.AddVariable(_T("WINDRES"),l_pCompiler->GetPrograms().WINDRES);
}
const wxArrayString& l_CommandsBeforeBuild = p_BuildTarget->GetCommandsBeforeBuild();
const wxArrayString& l_CommandsAfterBuild = p_BuildTarget->GetCommandsAfterBuild();
wxString l_TargetFileName = p_BuildTarget->GetOutputFilename();
Manager::Get()->GetMacrosManager()->ReplaceMacros(l_TargetFileName, p_BuildTarget);
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::formFileForTarget" ), l_TargetFileName );
#endif
wxFileName l_OutFileName = UnixFilename(l_TargetFileName);
wxString l_OutFileNameFullPath = l_OutFileName.GetFullPath();
QuoteStringIfNeeded( l_OutFileNameFullPath );
wxString l_OutFileNameFullPathMakefileFriendly = l_OutFileNameFullPath;
ConvertToMakefileFriendly( l_OutFileNameFullPathMakefileFriendly );
cbMGRule l_Rule;
if ( 0 == l_TargetName.CmpNoCase( _T( "default" ) ) )
{
l_Rule.SetTarget( _T( "all" ) );
}
else
{
l_Rule.SetTarget( l_TargetName );
}
wxString l_Pre;
if ( l_CommandsBeforeBuild.GetCount() > 0 )
{
l_Pre = l_CmdBefore;
}
l_Pre += l_OutFileNameFullPathMakefileFriendly;
if ( l_CommandsAfterBuild.GetCount() > 0 )
{
l_Pre += _T(" ") + l_CmdAfter;
}
l_Rule.SetPrerequisites( l_Pre );
m_Rules.Add( l_Rule );
if ( l_CommandsBeforeBuild.GetCount() > 0 )
{
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( l_CmdBefore );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( l_CmdBefore );
for ( unsigned long idx = 0; idx < l_CommandsBeforeBuild.GetCount(); idx ++ )
{
l_Rule.AddCommand( l_CommandsBeforeBuild[ idx ] );
}
m_Rules.Add( l_Rule );
}
if ( l_CommandsAfterBuild.GetCount() > 0 )
{
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( l_CmdAfter );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( l_CmdAfter );
for ( unsigned long idx = 0; idx < l_CommandsAfterBuild.GetCount(); idx ++ )
{
l_Rule.AddCommand( l_CommandsAfterBuild[ idx ] );
}
m_Rules.Add( l_Rule );
}
l_Rule.Clear();
l_Rule.SetTarget( l_OutFileNameFullPathMakefileFriendly );
l_Rule.SetPrerequisites( _T("$(") + l_ObjsName + _T(")") );
wxString kind_of_output = _T( "unknown" );
CommandType ct = ctCount;
bool l_TargetTypeValid = true;
switch ( p_BuildTarget->GetTargetType() )
{
case ttConsoleOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _T( "console executable" );
break;
case ttExecutable:
ct = ctLinkExeCmd;
kind_of_output = _T( "executable" );
break;
case ttDynamicLib:
ct = ctLinkDynamicCmd;
kind_of_output = _T( "dynamic library" );
break;
case ttStaticLib:
ct = ctLinkStaticCmd;
kind_of_output = _T( "static library" );
break;
case ttNative:
ct = ctLinkNativeCmd;
kind_of_output = _T( "native" );
break;
case ttCommandsOnly:
ct = ctLinkConsoleExeCmd;
kind_of_output = _T( "commands only" );
break;
default:
l_TargetTypeValid = false;
break;
// case ttCommandsOnly:
// // add target post-build commands
// ret.Clear();
// AppendArray(GetPostBuildCommands(target), ret);
// return ret;
// break;
break;
}
/*if(ttCommandsOnly == lTarget->GetTargetType())
{
GetPostBuildCommands(lTarget);
}
else*/
{
l_Rule.AddCommand( _T( "echo Building " ) + kind_of_output + _T( " " ) + l_OutFileNameFullPath );
if( l_TargetTypeValid )
{
wxString l_LinkerCmd = l_pCompiler->GetCommand( ct );
#if wxCHECK_VERSION(2, 9, 0)
Manager::Get()->GetLogManager()->DebugLog(wxString::Format( _("LinkerCmd: %s"), l_LinkerCmd.wx_str()) );
#else
Manager::Get()->GetLogManager()->DebugLog(wxString::Format( _("LinkerCmd: %s"), l_LinkerCmd.c_str()) );
#endif
l_pCompiler->GenerateCommandLine( l_LinkerCmd,
p_BuildTarget,
NULL,
l_OutFileNameFullPath,
// _T("$$(") + l_TargetName + _T(")"),
/* fix by oBFusCATed */
_T("$$(") + l_ObjsName + _T(")"),
wxEmptyString,
wxEmptyString );
l_Rule.AddCommand( l_LinkerCmd );
}
}
m_Rules.Add( l_Rule );
// Form rules
wxString l_Tmp;
unsigned long ii;
wxString macro;
wxString file;
wxString object;
wxString FlatObject;
wxString deps;
cbMGSortFilesArray files = GetProjectFilesSortedByWeight(p_BuildTarget,true,false);
unsigned long lnb_files = files.GetCount();
// fix by Sasquatch_47
//need to clear the m_Objs string for cases where one is generating a makefile for more than one configuration
m_Objs.clear();
for ( ii = 0; ii < lnb_files; ii++ )
{
l_Rule.Clear();
ProjectFile* pf = files[ ii ];
const pfDetails& pfd = pf->GetFileDetails( p_BuildTarget );
wxString l_Object = ( l_pCompiler->GetSwitches().UseFlatObjects )?pfd.object_file_flat:pfd.object_file;
wxString l_CompilerCmd;
// lookup file's type
FileType ft = FileTypeOf( pf->relativeFilename );
bool isResource = ft == ftResource;
bool isHeader = ft == ftHeader;
if ( !isHeader || l_pCompiler->GetSwitches().supportsPCH )
{
pfCustomBuild& pcfb = pf->customBuild[l_pCompiler->GetID()];
l_CompilerCmd = pcfb.useCustomBuildCommand
? pcfb.buildCommand
: l_pCompiler->GetCommand( isResource ? ctCompileResourceCmd : ctCompileObjectCmd );
wxString l_SourceFile;
wxString l_SourceFileMakefileFriendly;
if ( l_pCompiler->GetSwitches().UseFullSourcePaths )
{
wxString l_fName = pfd.source_file_absolute_native;
if( l_fName != wxEmptyString )
{
#ifdef USE_DEBUGSAVE
p_File.AddLine( _T("# File: ") + pfd.source_file_absolute_native );
p_File.AddLine( _T("# File: ") + l_fName );
p_File.AddLine( wxEmptyString );
#endif
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::formFileForTarget" ), l_fName );
#endif
l_SourceFile = UnixFilename( l_fName );
// for resource files, use short from if path because if windres bug with spaces-in-paths
if ( isResource )
{
l_SourceFile = pf->file.GetShortPath();
}
}
}
else
{
l_SourceFile = pfd.source_file;
}
l_SourceFileMakefileFriendly = l_SourceFile;
ConvertToMakefileFriendly( l_SourceFileMakefileFriendly );
QuoteStringIfNeeded( l_SourceFile );
#if wxCHECK_VERSION(2, 9, 0)
Manager::Get()->GetLogManager()->DebugLog(wxString::Format( _("CompilerCmd: %s"), l_CompilerCmd.wx_str()) );
#else
Manager::Get()->GetLogManager()->DebugLog(wxString::Format( _("CompilerCmd: %s"), l_CompilerCmd.c_str()) );
#endif
/* FIXME: traps after next command */
l_pCompiler->GenerateCommandLine( l_CompilerCmd,
p_BuildTarget,
pf,
l_SourceFile,
l_Object,
pfd.object_file_flat,
pfd.dep_file );
if ( m_Objs.size() )
{
m_Objs += _T(' ');
}
m_Objs += l_Object;
l_Rule.SetTarget( l_Object );
l_Rule.SetPrerequisites( l_SourceFileMakefileFriendly );
l_Rule.AddCommand( _T( "echo Compiling: " ) + l_SourceFile );
l_Rule.AddCommand( l_CompilerCmd );
m_Rules.Add( l_Rule );
}
}
for ( unsigned long i=0; i < m_Deps.Count(); i++ )
{
l_Rule.Clear();
l_Rule.SetTarget( m_Deps.GetVarName( i ) );
l_Rule.SetPrerequisites( m_Deps.GetVariable( i ) );
m_Rules.Add( l_Rule );
}
l_Rule.Clear();
l_Rule.SetTarget( cmdphony );
l_Rule.SetPrerequisites( l_CmdClean );
m_Rules.Add( l_Rule );
l_Rule.Clear();
l_Rule.SetTarget( l_CmdClean );
l_Rule.AddCommand( _T( "echo Delete $(" ) + l_ObjsName + _T( ") " ) + l_OutFileNameFullPath );
#ifdef __WXMSW__
l_Rule.AddCommand( _T( "-del /f $(" ) + l_ObjsName + _T( ") " ) + l_OutFileNameFullPath );
#else
l_Rule.AddCommand( _T( "-rm -f $(" ) + l_ObjsName + _T( ") " ) + l_OutFileNameFullPath );
#endif
m_Rules.Add( l_Rule );
if ( !m_VariablesIsSaved )
{
m_Variables.SaveAllVars( p_File );
m_VariablesIsSaved = true;
}
p_File.AddLine( _T("# Target: ") + l_TargetName );
p_File.AddLine( wxEmptyString );
p_File.AddLine( l_ObjsName + _T("=") + m_Objs );
p_File.AddLine( wxEmptyString );
SaveAllRules( p_File );
p_File.AddLine( wxEmptyString );
p_File.AddLine( wxEmptyString );
l_Ret = true;
return l_Ret;
}
bool cbMGMakefile::reLoadDependecies(const wxString &p_DepsFileName,ProjectBuildTarget *p_pTarget,Compiler* p_pCompiler)
{
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, Start" ), p_pTarget->GetTitle() );
#endif
m_Deps.Clear();
if ( !wxFileExists( p_DepsFileName ) )
{
wxString l_Msg = _( "Dependencies file (.depend) is absent!\n"
"C::B MakefileGen could not complete the operation." );
cbMessageBox( l_Msg, _( "Error" ), wxICON_ERROR | wxOK, (wxWindow *)Manager::Get()->GetAppWindow() );
Manager::Get()->GetLogManager()->DebugLog( l_Msg );
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies" ), _T( "End false" ) );
#endif
return false;
}
wxString l_Buf;
wxString l_VarName;
wxTextFile l_DepFile;
wxString l_TargetName = p_pTarget->GetTitle();
bool IsSkipThisFile = true;
if (l_DepFile.Open( p_DepsFileName, wxConvFile ))
{
for ( unsigned long i = 0; i < l_DepFile.GetLineCount(); i++ )
{
l_Buf = l_DepFile[i];
l_Buf.Trim(true);
// Wrong! Don't uncomment it! Being deleted '\t' symbol! l_Buf.Trim(false);
if ( l_Buf.IsEmpty() )
{
l_VarName.Clear();
IsSkipThisFile = true;
continue;
}
if ( _T('#') == l_Buf[0] ) continue;
if ( _T('\t') == l_Buf[0] )
{
if ( !IsSkipThisFile )
{
if ( _T('"') == l_Buf[1] )
{
wxString l_TmpName = l_Buf.AfterFirst( _T('\t') );
if (!l_TmpName.IsEmpty() && l_TmpName.GetChar(0) == _T('"') && l_TmpName.Last() == _T('"'))
l_TmpName = l_TmpName.Mid(1, l_TmpName.Length() - 2);
QuoteStringIfNeeded( l_TmpName );
m_Deps.AppendValue( l_VarName, l_TmpName );
}
}
}
else
{
l_VarName = l_Buf.AfterFirst(_T(' '));
bool IsSource = l_VarName.Matches( _T("source:*") );
if ( IsSource )
{
l_VarName = l_VarName.AfterFirst( _T(':') );
}
/*
* You would MUST found source file and get his filename from project
* !!! .depend file content lowcase filenames
*/
wxFileName l_DepFileName = l_VarName;
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, depfilename" ), l_VarName.wc_str() );
#endif
ProjectFile *pf = m_pProj->GetFileByFilename( l_DepFileName.GetFullPath(), l_DepFileName.IsRelative(), false );
if ( pf )
{
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, pf readed" ), pf->GetObjName() );
#endif
if( pf->buildTargets.Index( l_TargetName ) != wxNOT_FOUND )
{
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, before pfd read, target" ), l_TargetName );
#endif
const pfDetails& pfd = pf->GetFileDetails( p_pTarget );
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, pfd readed" ), pfd.dep_dir );
#endif
if ( p_pCompiler->GetSwitches().UseFullSourcePaths )
{
l_VarName = UnixFilename( pfd.source_file_absolute_native );
}
else
{
l_VarName = pfd.source_file;
}
QuoteStringIfNeeded( l_VarName );
IsSkipThisFile = false;
}
else
{
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies, pf skip" ), pf->GetObjName() );
#endif
IsSkipThisFile = true;
}
}
else
{
IsSkipThisFile = true;
}
}
}
}
/* FIXME (kisoftcb#1#): Next code for debug only!
wxTextFile l_DebFile;
l_DebFile.Create( _T("D:/DepsFile.log") );
m_Deps.SaveAllVars( l_DebFile );
l_DebFile.Write();
l_DebFile.Close(); */
/* return was absent here! */
#ifdef USE_PRINTLOG
printLog( _T( "cbMGMakefile::reLoadDependecies" ), _T( "End true" ) );
#endif
return true;
}
