void Foam::codedBase::unloadLibrary
(
const fileName& libPath,
const string& globalFuncName,
const dictionary& contextDict
) const
{
void* lib = 0;
if (libPath.empty())
{
return;
}
lib = libs().findLibrary(libPath);
if (!lib)
{
return;
}
// provision for manual execution of code before unloading
if (dlSymFound(lib, globalFuncName))
{
loaderFunctionType function =
reinterpret_cast<loaderFunctionType>
(
dlSym(lib, globalFuncName)
);
if (function)
{
(*function)(false); // force unload
}
else
{
FatalIOErrorInFunction
(
contextDict
) << "Failed looking up symbol " << globalFuncName << nl
<< "from " << libPath << exit(FatalIOError);
}
}
if (!libs().close(libPath, false))
{
FatalIOErrorInFunction
(
contextDict
) << "Failed unloading library " << libPath
<< exit(FatalIOError);
}
}
int main( int argc, char** argv )
{
avtranscoder::Libraries libs( avtranscoder::getLibraries() );
for( avtranscoder::Libraries::iterator library = libs.begin(); library != libs.end(); ++library )
{
std::cout << std::left;
std::cout << std::setw( 15 ) << (*library).getName();
std::cout << std::setw( 10 ) << (*library).getStringVersion();
std::cout << std::setw( 30 ) << (*library).getLicense();
std::cout << std::endl;
}
avtranscoder::preloadCodecsAndFormats();
std::vector<std::string> inputExtension = avtranscoder::getInputExtensions();
std::vector<std::string> outputExtension = avtranscoder::getOutputExtensions();
std::cout << "Supported input extensions: " << inputExtension.size() << std::endl;
for( std::vector<std::string>::iterator it = inputExtension.begin(); it != inputExtension.end(); ++it )
std::cout << *it << ", ";;
std::cout << std::endl << std::endl << "Supported output extensions: " << outputExtension.size() << std::endl;
for( std::vector<std::string>::iterator it = outputExtension.begin(); it != outputExtension.end(); ++it )
std::cout << *it << ", ";
std::cout << std::endl;
return 0;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
Libs libs(NULL, false, CollationLevel_NONE, COLLATE_FUNC_NONE);
List dict_list;
libs.load(dict_list);
std::vector<double> times;
for (int i=0; i<10; ++i) {
clock_t t=clock();
fuzzy_lookup(libs, "mather");
fuzzy_lookup(libs, "try thes");
fuzzy_lookup(libs, "wths up man?");
fuzzy_lookup(libs, "faind fiz");
fuzzy_lookup(libs, "u can not find?");
fuzzy_lookup(libs, "starnge");
t=clock()-t;
times.push_back(double(t)/CLOCKS_PER_SEC);
// std::cout<<double(t)/CLOCKS_PER_SEC<<std::endl;
}
std::cout<<average_time(times)<<std::endl;
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
List dirs;
gtk_init(&argc, &argv);
#if !defined(_WIN32)
dirs.push_back("/usr/share/stardict/dic");
dirs.push_back(std::string(g_get_home_dir())+"/.stardict/dic");
#endif
Libs libs(NULL, false, false, 0);
libs.load(dirs, List(), List());
std::vector<double> times;
for (int i=0; i<10; ++i) {
clock_t t=clock();
fuzzy_lookup(libs, "mather");
fuzzy_lookup(libs, "try thes");
fuzzy_lookup(libs, "wths up man?");
fuzzy_lookup(libs, "faind fiz");
fuzzy_lookup(libs, "u can not find?");
fuzzy_lookup(libs, "starnge");
t=clock()-t;
times.push_back(double(t)/CLOCKS_PER_SEC);
// std::cout<<double(t)/CLOCKS_PER_SEC<<std::endl;
}
std::cout<<average_time(times)<<std::endl;
return EXIT_SUCCESS;
}
void Foam::codedBase::updateLibrary
(
const word& name
) const
{
const dictionary& dict = this->codeDict();
dynamicCode::checkSecurity
(
"codedBase::updateLibrary()",
dict
);
dynamicCodeContext context(dict);
// codeName: name + _<sha1>
// codeDir : name
dynamicCode dynCode
(
name + context.sha1().str(true),
name
);
const fileName libPath = dynCode.libPath();
// the correct library was already loaded => we are done
if (libs().findLibrary(libPath))
{
return;
}
Info<< "Using dynamicCode for " << this->description().c_str()
<< " at line " << dict.startLineNumber()
<< " in " << dict.name() << endl;
// remove instantiation of fvPatchField provided by library
this->clearRedirect();
// may need to unload old library
unloadLibrary
(
oldLibPath_,
dynamicCode::libraryBaseName(oldLibPath_),
context.dict()
);
// try loading an existing library (avoid compilation when possible)
if (!loadLibrary(libPath, dynCode.codeName(), context.dict()))
{
createLibrary(dynCode, context);
loadLibrary(libPath, dynCode.codeName(), context.dict());
}
// retain for future reference
oldLibPath_ = libPath;
}
std::string
helperGetLibsUsed(void)
{
std::stringstream libs(ARCH->getLibsUsed());
std::string msg;
std::string pid;
std::getline(libs,pid);
while( std::getline(libs,msg) ) {
LOG(( CLOG_DEBUG "libs:%s",msg.c_str()));
}
return pid;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
Libs libs(NULL, false, false, 0);
List dict_list;
libs.load(dict_list);
std::vector<InstantDictIndex> dictmask;
std::vector<gchar *> reslist[dictmask.size()];
if (libs.LookupData("letter", reslist, NULL, NULL, NULL, dictmask))
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
}
QString GameLauncher::libPathGen() {
QString libPath = "";
libPath.append(" -cp \"");
QFile libs( QDir::currentPath()+"/versions/"+version+"/libs.txt" );
if( libs.open( QIODevice::ReadOnly | QIODevice::Text ) ) {
libs.resize( 0 );
QTextStream out( &libs );
libPath.append( out.readAll() );
libs.close();
}
libPath.append( mainPath+slash+"versions"+slash+version+slash+version+".jar\"");
return libPath;
}
Foam::functionEntries::codeStream::streamingFunctionType
Foam::functionEntries::codeStream::getFunction
(
const dictionary& parentDict,
const dictionary& codeDict
)
{
// get code, codeInclude, codeOptions
dynamicCodeContext context(codeDict);
// codeName: codeStream + _<sha1>
// codeDir : _<sha1>
dynamicCode dynCode
(
"codeStream" + context.sha1().str(true),
context.sha1().str(true)
);
// Load library if not already loaded
// Version information is encoded in the libPath (encoded with the SHA1)
const fileName libPath = dynCode.libPath();
// see if library is loaded
void* lib = NULL;
if (isA<IOdictionary>(topDict(parentDict)))
{
lib = libs(parentDict).findLibrary(libPath);
}
if (!lib)
{
Info<< "Using #codeStream with " << libPath << endl;
}
// nothing loaded
// avoid compilation if possible by loading an existing library
if (!lib)
{
if (isA<IOdictionary>(topDict(parentDict)))
{
// Cached access to dl libs. Guarantees clean up upon destruction
// of Time.
dlLibraryTable& dlLibs = libs(parentDict);
if (dlLibs.open(libPath, false))
{
lib = dlLibs.findLibrary(libPath);
}
}
else
{
// Uncached opening of libPath. Do not complain if cannot be loaded
lib = dlOpen(libPath, false);
}
}
// create library if required
if (!lib)
{
bool create = Pstream::master();
if (create)
{
if (!dynCode.upToDate(context))
{
// filter with this context
dynCode.reset(context);
// compile filtered C template
dynCode.addCompileFile(codeTemplateC);
// define Make/options
dynCode.setMakeOptions
(
"EXE_INC = -g \\\n"
+ context.options()
+ "\n\nLIB_LIBS = \\\n"
+ " -lOpenFOAM \\\n"
+ context.libs()
);
if (!dynCode.copyOrCreateFiles(true))
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed writing files for" << nl
<< dynCode.libRelPath() << nl
<< exit(FatalIOError);
}
}
if (!dynCode.wmakeLibso())
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed wmake " << dynCode.libRelPath() << nl
<< exit(FatalIOError);
}
}
//- Only block if we're not doing master-only reading. (flag set by
// regIOobject::read, IOdictionary constructor)
if (!regIOobject::masterOnlyReading)
{
reduce(create, orOp<bool>());
}
if (isA<IOdictionary>(topDict(parentDict)))
{
// Cached access to dl libs. Guarantees clean up upon destruction
// of Time.
dlLibraryTable& dlLibs = libs(parentDict);
if (!dlLibs.open(libPath, false))
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed loading library " << libPath << nl
<< "Did you add all libraries to the 'libs' entry"
<< " in system/controlDict?"
<< exit(FatalIOError);
}
lib = dlLibs.findLibrary(libPath);
}
else
{
// Uncached opening of libPath
lib = dlOpen(libPath, true);
}
}
// Find the function handle in the library
streamingFunctionType function =
reinterpret_cast<streamingFunctionType>
(
dlSym(lib, dynCode.codeName())
);
if (!function)
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed looking up symbol " << dynCode.codeName()
<< " in library " << lib << exit(FatalIOError);
}
return function;
}
Foam::functionEntries::codeStream::streamingFunctionType
Foam::functionEntries::codeStream::getFunction
(
const dictionary& parentDict,
const dictionary& codeDict
)
{
// get code, codeInclude, codeOptions
dynamicCodeContext context(codeDict);
// codeName: codeStream + _<sha1>
// codeDir : _<sha1>
std::string sha1Str(context.sha1().str(true));
dynamicCode dynCode("codeStream" + sha1Str, sha1Str);
// Load library if not already loaded
// Version information is encoded in the libPath (encoded with the SHA1)
const fileName libPath = dynCode.libPath();
// see if library is loaded
void* lib = NULL;
if (isA<IOdictionary>(topDict(parentDict)))
{
lib = libs(parentDict).findLibrary(libPath);
}
if (!lib)
{
Info<< "Using #codeStream with " << libPath << endl;
}
// nothing loaded
// avoid compilation if possible by loading an existing library
if (!lib)
{
if (isA<IOdictionary>(topDict(parentDict)))
{
// Cached access to dl libs. Guarantees clean up upon destruction
// of Time.
dlLibraryTable& dlLibs = libs(parentDict);
if (dlLibs.open(libPath, false))
{
lib = dlLibs.findLibrary(libPath);
}
}
else
{
// Uncached opening of libPath. Do not complain if cannot be loaded
lib = dlOpen(libPath, false);
}
}
// create library if required
if (!lib)
{
bool create =
Pstream::master()
|| (regIOobject::fileModificationSkew <= 0); // not NFS
if (create)
{
if (!dynCode.upToDate(context))
{
// filter with this context
dynCode.reset(context);
// compile filtered C template
dynCode.addCompileFile(codeTemplateC);
// define Make/options
dynCode.setMakeOptions
(
"EXE_INC = -g \\\n"
+ context.options()
+ "\n\nLIB_LIBS = \\\n"
+ " -lOpenFOAM \\\n"
+ context.libs()
);
if (!dynCode.copyOrCreateFiles(true))
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed writing files for" << nl
<< dynCode.libRelPath() << nl
<< exit(FatalIOError);
}
}
if (!dynCode.wmakeLibso())
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed wmake " << dynCode.libRelPath() << nl
<< exit(FatalIOError);
}
}
//- Only block if we're not doing master-only reading. (flag set by
// regIOobject::read, IOdictionary constructor)
if
(
!regIOobject::masterOnlyReading
&& regIOobject::fileModificationSkew > 0
)
{
//- Since the library has only been compiled on the master the
// other nodes need to pick this library up through NFS
// We do this by just polling a few times using the
// fileModificationSkew.
off_t mySize = Foam::fileSize(libPath);
off_t masterSize = mySize;
Pstream::scatter(masterSize);
if (debug)
{
Pout<< endl<< "on processor " << Pstream::myProcNo()
<< " have masterSize:" << masterSize
<< " and localSize:" << mySize
<< endl;
}
if (mySize < masterSize)
{
if (debug)
{
Pout<< "Local file " << libPath
<< " not of same size (" << mySize
<< ") as master ("
<< masterSize << "). Waiting for "
<< regIOobject::fileModificationSkew
<< " seconds." << endl;
}
Foam::sleep(regIOobject::fileModificationSkew);
// Recheck local size
mySize = Foam::fileSize(libPath);
if (mySize < masterSize)
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Cannot read (NFS mounted) library " << nl
<< libPath << nl
<< "on processor " << Pstream::myProcNo()
<< " detected size " << mySize
<< " whereas master size is " << masterSize
<< " bytes." << nl
<< "If your case is not NFS mounted"
<< " (so distributed) set fileModificationSkew"
<< " to 0"
<< exit(FatalIOError);
}
}
if (debug)
{
Pout<< endl<< "on processor " << Pstream::myProcNo()
<< " after waiting: have masterSize:" << masterSize
<< " and localSize:" << mySize
<< endl;
}
}
if (isA<IOdictionary>(topDict(parentDict)))
{
// Cached access to dl libs. Guarantees clean up upon destruction
// of Time.
dlLibraryTable& dlLibs = libs(parentDict);
if (debug)
{
Pout<< "Opening cached dictionary:" << libPath << endl;
}
if (!dlLibs.open(libPath, false))
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed loading library " << libPath << nl
<< "Did you add all libraries to the 'libs' entry"
<< " in system/controlDict?"
<< exit(FatalIOError);
}
lib = dlLibs.findLibrary(libPath);
}
else
{
// Uncached opening of libPath
if (debug)
{
Pout<< "Opening uncached dictionary:" << libPath << endl;
}
lib = dlOpen(libPath, true);
}
}
bool haveLib = lib;
reduce(haveLib, andOp<bool>());
if (!haveLib)
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed loading library " << libPath
<< " on some processors."
<< exit(FatalIOError);
}
// Find the function handle in the library
streamingFunctionType function =
reinterpret_cast<streamingFunctionType>
(
dlSym(lib, dynCode.codeName())
);
if (!function)
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
parentDict
) << "Failed looking up symbol " << dynCode.codeName()
<< " in library " << lib << exit(FatalIOError);
}
return function;
}
void* Foam::codedBase::loadLibrary
(
const fileName& libPath,
const string& globalFuncName,
const dictionary& contextDict
) const
{
void* lib = 0;
// avoid compilation by loading an existing library
if (!libPath.empty())
{
if (libs().open(libPath, false))
{
lib = libs().findLibrary(libPath);
// verify the loaded version and unload if needed
if (lib)
{
// provision for manual execution of code after loading
if (dlSymFound(lib, globalFuncName))
{
loaderFunctionType function =
reinterpret_cast<loaderFunctionType>
(
dlSym(lib, globalFuncName)
);
if (function)
{
(*function)(true); // force load
}
else
{
FatalIOErrorInFunction
(
contextDict
) << "Failed looking up symbol " << globalFuncName
<< nl << "from " << libPath << exit(FatalIOError);
}
}
else
{
FatalIOErrorInFunction
(
contextDict
) << "Failed looking up symbol " << globalFuncName << nl
<< "from " << libPath << exit(FatalIOError);
lib = 0;
if (!libs().close(libPath, false))
{
FatalIOErrorInFunction
(
contextDict
) << "Failed unloading library "
<< libPath
<< exit(FatalIOError);
}
}
}
}
}
return lib;
}
void Hyperon(const char* dataset="collection.xml")
{
/* $Id$ */
TStopwatch timer;
timer.Start();
TStringToken libs("Core,Tree,Geom,VMC,Physics,Minuit,Gui,XMLParser,Minuit2,Proof,STEERBase,ESD,AOD,OADB,ANALYSIS,ANALYSISalice,CDB,RAWDatabase,STEER,CORRFW,PHOSUtils,PHOSbase,PHOSpi0Calib,PHOSrec,PHOSshuttle,PHOSsim", ",");
while( libs.NextToken() )
gSystem->Load( Form("lib%s", libs.Data()) );
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
gSystem->Load("libPWGGAGammaConv");
gSystem->Load("libPWGGAHyperon");
//load analysis framework
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
// Connect to alien
TString token = gSystem->Getenv("GRID_TOKEN") ;
if (1) // token == "OK" )
TGrid::Connect("alien://");
else
AliInfo("You are not connected to the GRID") ;
cout << "Pi0Analysis: processing collection " << dataset << endl;
// Create the chain
TChain* chain = new TChain("aodTree");
TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
TAlienResult* result = collection->GetGridResult("",0 ,0);
TList* rawFileList = result->GetFileInfoList();
for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
TFileInfo * fi = static_cast<TFileInfo*>(rawFileList->At(counter)) ;
const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;
printf("Processing %s\n", rawFile) ;
chain->Add(rawFile);
printf("Chain: %d entries.\n",chain->GetEntriesFast());
}
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("Hyperon");
mgr->SetCommonFileName("histos.root");
// AOD input handler
AliAODInputHandler* aodH = new AliAODInputHandler();
mgr->SetInputEventHandler(aodH);
// Debug level
mgr->SetDebugLevel(2);
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C");
AliCentralitySelectionTask* taskCentrality = AddTaskCentrality();
if (analysisMC)
taskCentrality->SetMCInput();
// // Update it for Hyperon (YK 22.01.2015)
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
// AliEPSelectionTask *taskEP = AddTaskEventplane() ;
// gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
// AliVZEROEPSelectionTask *selTask = AddTaskVZEROEPSelection();
// Add my task
AliAnalysisHyperon* task = new AliAnalysisHyperon();
// gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPb/AddTaskPHOSPi0Flow.C"); // Update it for Hyperon (YK 22.01.2015)
// task = AddTaskPHOSPi0Flow();
// // Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("Hyperon",TList::Class(),AliAnalysisManager::kOutputContainer,"HyperonHist.root");
// // Connect input/output
mgr->ConnectInput(task , 0, cinput);
mgr->ConnectOutput(task, 1, coutput1);
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("local", chain);
}
timer.Stop();
timer.Print();
}
void ArcAPI::create_out_archive(const ArcType& arc_type, IOutArchive** out_arc) {
CHECK_COM(libs()[formats().at(arc_type).lib_index].CreateObject(reinterpret_cast<const GUID*>(arc_type.data()), &IID_IOutArchive, reinterpret_cast<void**>(out_arc)));
}
// GetOtherLibraries
//------------------------------------------------------------------------------
bool LinkerNode::GetOtherLibraries( NodeGraph & nodeGraph,
const BFFIterator & iter,
const Function * function,
const AString & args,
Dependencies & otherLibraries,
bool msvc ) const
{
// split to individual tokens
Array< AString > tokens;
args.Tokenize( tokens );
bool ignoreAllDefaultLibs = false;
Array< AString > defaultLibsToIgnore( 8, true );
Array< AString > defaultLibs( 16, true );
Array< AString > libs( 16, true );
Array< AString > dashlLibs( 16, true );
Array< AString > libPaths( 16, true );
Array< AString > envLibPaths( 32, true );
// extract lib path from system if present
AStackString< 1024 > libVar;
if ( Env::GetEnvVariable( "LIB", libVar ) )
{
libVar.Tokenize( envLibPaths, ';' );
}
const AString * const end = tokens.End();
for ( const AString * it = tokens.Begin(); it != end; ++it )
{
const AString & token = *it;
// MSVC style
if ( msvc )
{
// /NODEFAULTLIB
if ( LinkerNode::IsLinkerArg_MSVC( token, "NODEFAULTLIB" ) )
{
ignoreAllDefaultLibs = true;
continue;
}
// /NODEFAULTLIB:
if ( GetOtherLibsArg( "NODEFAULTLIB:", defaultLibsToIgnore, it, end, false, msvc ) )
{
continue;
}
// /DEFAULTLIB:
if ( GetOtherLibsArg( "DEFAULTLIB:", defaultLibs, it, end, false, msvc ) )
{
continue;
}
// /LIBPATH:
if ( GetOtherLibsArg( "LIBPATH:", libPaths, it, end, true, msvc ) ) // true = canonicalize path
{
continue;
}
// some other linker argument?
if ( token.BeginsWith( '/' ) || token.BeginsWith( '-' ) )
{
continue;
}
}
// GCC/SNC style
if ( !msvc )
{
// We don't need to check for this, as there is no default lib passing on
// the cmd line.
// -nodefaultlibs
//if ( token == "-nodefaultlibs" )
//{
// ignoreAllDefaultLibs = true;
// continue;
//}
// -L (lib path)
if ( GetOtherLibsArg( "L", libPaths, it, end, false, msvc ) )
{
continue;
}
// -l (lib)
if ( GetOtherLibsArg( "l", dashlLibs, it, end, false, msvc ) )
{
continue;
}
// some other linker argument?
if ( token.BeginsWith( '-' ) )
{
continue;
}
}
// build time substitution?
if ( token.BeginsWith( '%' ) || // %1
token.BeginsWith( "'%" ) || // '%1'
token.BeginsWith( "\"%" ) ) // "%1"
{
continue;
}
// anything left is an input to the linker
AStackString<> libName;
Args::StripQuotes( token.Get(), token.GetEnd(), libName );
if ( token.IsEmpty() == false )
{
libs.Append( libName );
}
}
// filter default libs
if ( ignoreAllDefaultLibs )
{
// filter all default libs
defaultLibs.Clear();
}
else
{
// filter specifically listed default libs
const AString * const endI = defaultLibsToIgnore.End();
for ( const AString * itI = defaultLibsToIgnore.Begin(); itI != endI; ++itI )
{
const AString * const endD = defaultLibs.End();
for ( AString * itD = defaultLibs.Begin(); itD != endD; ++itD )
{
if ( itI->CompareI( *itD ) == 0 )
{
defaultLibs.Erase( itD );
break;
}
}
}
}
if ( !msvc )
{
// convert -l<name> style libs to lib<name>.a
const AString * const endDL = dashlLibs.End();
for ( const AString * itDL = dashlLibs.Begin(); itDL != endDL; ++itDL )
{
AStackString<> libName;
libName += "lib";
libName += *itDL;
libName += ".a";
libs.Append( libName );
}
}
// any remaining default libs are treated the same as libs
libs.Append( defaultLibs );
// use Environment libpaths if found (but used after LIBPATH provided ones)
libPaths.Append( envLibPaths );
// convert libs to nodes
const AString * const endL = libs.End();
for ( const AString * itL = libs.Begin(); itL != endL; ++itL )
{
bool found = false;
// is the file a full path?
if ( ( itL->GetLength() > 2 ) && ( (*itL)[ 1 ] == ':' ) )
{
// check file exists in current location
if ( !GetOtherLibrary( nodeGraph, iter, function, otherLibraries, AString::GetEmpty(), *itL, found ) )
{
return false; // GetOtherLibrary will have emitted error
}
}
else
{
// check each libpath
const AString * const endP = libPaths.End();
for ( const AString * itP = libPaths.Begin(); itP != endP; ++itP )
{
if ( !GetOtherLibrary( nodeGraph, iter, function, otherLibraries, *itP, *itL, found ) )
{
return false; // GetOtherLibrary will have emitted error
}
if ( found )
{
break;
}
// keep searching lib paths...
}
}
// file does not exist on disk, and there is no rule to build it
// Don't complain about this, because:
// a) We may be parsing rules on another OS (i.e. parsing Linux rules on Windows)
// b) User may have filtered some libs for platforms they don't care about (i.e. libs
// for PS4 on a PC developer's machine on a cross-platform team)
// If the file is actually needed, the linker will emit an error during link-time.
}
return true;
}