int __hxcpp_unload_all_libraries()
{
int unloaded = 0;
while(sgOrderedModules.size())
{
Module module = sgOrderedModules.back();
sgOrderedModules.pop_back();
hxFreeLibrary(module);
unloaded++;
}
return unloaded;
}
void C2Builder::generateOptionalIR() {
if (options.checkOnly) return;
if (!options.generateIR && !recipe.generateIR) return;
bool single_module = false;
for (unsigned i=0; i<recipe.genConfigs.size(); i++) {
const std::string& conf = recipe.genConfigs[i];
// TODO just pass struct with bools?
if (conf == "single-module") single_module = true;
else {
fprintf(stderr, ANSI_RED"invalid code generation argument '%s'" ANSI_NORMAL"\n", conf.c_str());
}
}
std::string outdir = OUTPUT_DIR + recipe.name + BUILD_DIR;
// TODO move all this to some generic Codegen class
// Q: use single context or one-per-module?
llvm::LLVMContext context;
const ModuleList& mods = mainComponent->getModules();
if (single_module) {
uint64_t t1 = Utils::getCurrentTime();
std::string filename = recipe.name;
if (options.verbose) log(COL_VERBOSE, "generating IR for single module %s", filename.c_str());
CodeGenModule cgm(filename, true, mods, context);
cgm.generate();
uint64_t t2 = Utils::getCurrentTime();
if (options.printTiming) log(COL_TIME, "IR generation took %" PRIu64" usec", t2 - t1);
if (options.printIR) cgm.dump();
bool ok = cgm.verify();
if (ok) cgm.write(outdir, filename);
} else {
for (unsigned m=0; m<mods.size(); m++) {
Module* M = mods[m];
uint64_t t1 = Utils::getCurrentTime();
if (M->isPlainC()) continue;
if (M->getName() == "c2") continue;
if (options.verbose) log(COL_VERBOSE, "generating IR for module %s", M->getName().c_str());
ModuleList single;
single.push_back(M);
CodeGenModule cgm(M->getName(), false, single, context);
cgm.generate();
uint64_t t2 = Utils::getCurrentTime();
if (options.printTiming) log(COL_TIME, "IR generation took %" PRIu64" usec", t2 - t1);
if (options.printIR) cgm.dump();
bool ok = cgm.verify();
if (ok) cgm.write(outdir, M->getName());
}
}
}
// Assume that dyld is in memory at ADDR and try to parse it's load commands
bool DynamicLoaderMacOSXDYLD::ReadDYLDInfoFromMemoryAndSetNotificationCallback(
lldb::addr_t addr) {
std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
DataExtractor data; // Load command data
static ConstString g_dyld_all_image_infos("dyld_all_image_infos");
if (ReadMachHeader(addr, &m_dyld.header, &data)) {
if (m_dyld.header.filetype == llvm::MachO::MH_DYLINKER) {
m_dyld.address = addr;
ModuleSP dyld_module_sp;
if (ParseLoadCommands(data, m_dyld, &m_dyld.file_spec)) {
if (m_dyld.file_spec) {
UpdateDYLDImageInfoFromNewImageInfo(m_dyld);
}
}
dyld_module_sp = GetDYLDModule();
Target &target = m_process->GetTarget();
if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS &&
dyld_module_sp.get()) {
const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType(
g_dyld_all_image_infos, eSymbolTypeData);
if (symbol)
m_dyld_all_image_infos_addr = symbol->GetLoadAddress(&target);
}
// Update all image infos
InitializeFromAllImageInfos();
// If we didn't have an executable before, but now we do, then the dyld
// module shared pointer might be unique and we may need to add it again
// (since Target::SetExecutableModule() will clear the images). So append
// the dyld module back to the list if it is
/// unique!
if (dyld_module_sp) {
target.GetImages().AppendIfNeeded(dyld_module_sp);
// At this point we should have read in dyld's module, and so we should
// set breakpoints in it:
ModuleList modules;
modules.Append(dyld_module_sp);
target.ModulesDidLoad(modules);
SetDYLDModule(dyld_module_sp);
}
return true;
}
}
return false;
}
void
ModuleManager::_FindBuiltInModules(const char *prefix, const char *suffix,
module_name_list *list)
{
uint32 count = fModules.CountModules();
uint32 prefixLength = strlen(prefix);
for (uint32 i = 0; i < count; i++) {
Module *module = fModules.ModuleAt(i);
if (!strncmp(module->Info()->name, prefix, prefixLength)
&& _MatchSuffix(module->Info()->name, suffix))
list->names.insert(module->Info()->name);
}
}
size_t
ModuleList::FindModules (const ModuleSpec &module_spec, ModuleList& matching_module_list) const
{
size_t existing_matches = matching_module_list.GetSize();
Mutex::Locker locker(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
ModuleSP module_sp(*pos);
if (module_sp->MatchesModuleSpec (module_spec))
matching_module_list.Append(module_sp);
}
return matching_module_list.GetSize() - existing_matches;
}
File EnabledModuleList::findDefaultModulesFolder (Project& project)
{
ModuleList available;
available.scanAllKnownFolders (project);
for (int i = available.modules.size(); --i >= 0;)
{
File f (available.modules.getUnchecked(i)->getFolder());
if (f.isDirectory())
return f.getParentDirectory();
}
return File::getCurrentWorkingDirectory();
}
status_t
ModuleManager::AddBuiltInModule(module_info *info)
{
BAutolock _lock(fModules);
TRACE(("add module %p, \"%s\"\n", info, info->name));
return fModules.AddModule(new Module(NULL, info)) ? B_OK : B_ERROR;
}
bool CSecurityCache::GetEigenvalue(ModuleList& mlist)
{
mlist.clear();
for(int i = 0; i < SECURE_BUCKET_SIZE; i++)
{
for(list<SecCachStruct*>::iterator ite = m_secuBucket[i].begin(); ite != m_secuBucket[i].end(); ite ++)
{
if(((*ite)->tag == 1) || (*ite)->tag == 3 || (*ite)->tag == 4)//有效数据
{
ModuleItem item;
memcpy(item.md,(void*)(*ite)->chkdata,SECURE_SIZE);
mlist.push_back(item);
}
}
}
return true;
}
void CGenerator::generate() {
std::string outdir = options.outputDir + targetName + options.buildDir;
MakefileGenerator makeGen(outdir, targetName, targetType);
if (options.single_module) {
makeGen.add(targetName);
CCodeGenerator gen(targetName, CCodeGenerator::SINGLE_FILE, moduleMap, mods, includeNamer);
gen.generate(options.printC, outdir);
} else {
for (unsigned m=0; m<mods.size(); m++) {
Module* M = mods[m];
makeGen.add(M->getName());
ModuleList single;
single.push_back(M);
CCodeGenerator gen(M->getName(), CCodeGenerator::MULTI_FILE, moduleMap, single, includeNamer);
gen.generate(options.printC, outdir);
}
}
for (StringListConstIter iter=libs.begin(); iter!=libs.end(); ++iter) {
makeGen.addLinkerLib(*iter);
}
makeGen.write();
// generate exports.version
if (targetType == GenUtils::SHARED_LIB) {
StringBuilder expmap;
expmap << "LIB_1.0 {\n";
expmap << "\tglobal:\n";
for (unsigned m=0; m<mods.size(); m++) {
const Module* M = mods[m];
const Module::Symbols& syms = M->getSymbols();
for (Module::SymbolsConstIter iter = syms.begin(); iter != syms.end(); ++iter) {
const Decl* D = iter->second;
if (!D->isExported()) continue;
if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) continue;
expmap << "\t\t";
GenUtils::addName(M->getName(), iter->first, expmap);
expmap << ";\n";
}
}
expmap << "\tlocal:\n\t\t*;\n";
expmap << "};\n";
std::string outfile = outdir + "exports.version";
FileUtils::writeFile(outdir.c_str(), outfile.c_str(), expmap);
}
}
void Project::warnAboutOldProjucerVersion()
{
ModuleList available;
available.scanAllKnownFolders (*this);
if (isAnyModuleNewerThanProjucer (available.modules))
{
if (ProjucerApplication::getApp().isRunningCommandLine)
std::cout << "WARNING! This version of the Projucer is out-of-date!" << std::endl;
else
AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon,
"Projucer",
"This version of the Projucer is out-of-date!"
"\n\n"
"Always make sure that you're running the very latest version, "
"preferably compiled directly from the JUCE repository that you're working with!");
}
}
void
AppleObjCRuntime::ReadObjCLibraryIfNeeded (const ModuleList &module_list)
{
if (!HasReadObjCLibrary ())
{
Mutex::Locker locker (module_list.GetMutex ());
size_t num_modules = module_list.GetSize();
for (size_t i = 0; i < num_modules; i++)
{
auto mod = module_list.GetModuleAtIndex (i);
if (IsModuleObjCLibrary (mod))
{
ReadObjCLibrary (mod);
break;
}
}
}
}
File EnabledModuleList::findDefaultModulesFolder (Project& project)
{
auto globalPath = findGlobalModulesFolder();
if (globalPath != File())
return globalPath;
ModuleList available;
available.scanProjectExporterModulePaths (project);
for (int i = available.modules.size(); --i >= 0;)
{
File f (available.modules.getUnchecked(i)->getFolder());
if (f.isDirectory())
return f.getParentDirectory();
}
return File::getCurrentWorkingDirectory();
}
// PutModule
status_t
ModuleManager::PutModule(const char *path)
{
if (path == NULL)
return B_BAD_VALUE;
BAutolock _lock(fModules);
if (Module *module = fModules.FindModule(path)) {
if (module->Put()) {
ModuleAddOn *addon = module->AddOn();
fModules.RemoveModule(module);
delete module;
_PutAddOn(addon);
}
} else
return B_BAD_VALUE;
return B_OK;
}
void Host::ScanInvalidModuleFiles()
{
ScopedLock lock(&moduleMutex);
this->autoScan = false; // Do not recursively scan
ModuleList modulesLoaded; // Track loaded modules
std::vector<std::string>::iterator iter;
iter = this->invalid_module_files.begin();
while (iter != this->invalid_module_files.end())
{
std::string path = *iter;
ModuleProvider *provider = FindModuleProvider(path);
if (provider != NULL)
{
SharedPtr<Module> m = this->LoadModule(path, provider);
// Module was loaded successfully
if (!m.isNull())
modulesLoaded.push_back(m);
// Erase path, even on failure
iter = invalid_module_files.erase(iter);
}
else
{
iter++;
}
}
if (modulesLoaded.size() > 0)
{
this->StartModules(modulesLoaded);
/* If any of the invalid module files added
* a ModuleProvider, let them load their modules */
this->ScanInvalidModuleFiles();
}
this->autoScan = true;
}
// @copydoc klk::IModuleFactory::getModulesWithoutRegistration
const ModuleList ModuleFactory::getModulesWithoutRegistration()
{
ModuleList list;
StringList ids = getModuleIDs();
for(StringList::iterator id = ids.begin(); id != ids.end(); id++)
{
Locker lock(&m_lock);
IModulePtr module = getModuleUnsafe(*id);
if (!module)
{
// not found here
// will try to find at the modules description
module = getLibFactory()->getModule(*id);
}
if (module)
{
list.push_back(module);
}
}
return list;
}
void enumAndLoadModuleSymbols( HANDLE hProcess, DWORD pid )
{
ModuleList modules;
ModuleListIter it;
char *img, *mod;
// fill in module list
fillModuleList( modules, pid, hProcess );
for ( it = modules.begin(); it != modules.end(); ++ it )
{
// unfortunately, SymLoadModule() wants writeable strings
img = new char[(*it).imageName.size() + 1];
strcpy( img, (*it).imageName.c_str() );
mod = new char[(*it).moduleName.size() + 1];
strcpy( mod, (*it).moduleName.c_str() );
SymLoadModule64( hProcess, 0, img, mod, (*it).baseAddress, (*it).size );
delete [] img;
delete [] mod;
}
}
void SearchFilter::SearchInModuleList(Searcher &searcher, ModuleList &modules) {
SymbolContext empty_sc;
if (!m_target_sp)
return;
empty_sc.target_sp = m_target_sp;
if (searcher.GetDepth() == lldb::eSearchDepthTarget)
searcher.SearchCallback(*this, empty_sc, nullptr, false);
else {
std::lock_guard<std::recursive_mutex> guard(modules.GetMutex());
const size_t numModules = modules.GetSize();
for (size_t i = 0; i < numModules; i++) {
ModuleSP module_sp(modules.GetModuleAtIndexUnlocked(i));
if (ModulePasses(module_sp)) {
if (DoModuleIteration(module_sp, searcher) ==
Searcher::eCallbackReturnStop)
return;
}
}
}
}
addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list,
const ConstString &name,
SymbolType symbol_type) const {
SymbolContextList target_symbols;
Target &target = m_process->GetTarget();
if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
target_symbols))
return LLDB_INVALID_ADDRESS;
SymbolContext sym_ctx;
target_symbols.GetContextAtIndex(0, sym_ctx);
const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
if (!jit_descriptor_addr.IsValid())
return LLDB_INVALID_ADDRESS;
const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
return jit_addr;
}
// GetNextLoadedModuleName
status_t
ModuleManager::GetNextLoadedModuleName(uint32 *cookie, char *buffer,
size_t *bufferSize)
{
status_t error = (cookie && buffer && bufferSize ? B_OK : B_BAD_VALUE);
if (error == B_OK) {
BAutolock _lock(fModules);
if (Module *module = fModules.ModuleAt(*cookie)) {
module_info *info = module->Info();
size_t nameLen = strlen(info->name);
if (nameLen < *bufferSize) {
strcpy(buffer, info->name);
*bufferSize = nameLen;
(*cookie)++;
} else
error = B_BAD_VALUE;
} else
error = B_ENTRY_NOT_FOUND;
}
return error;
}
void EnabledModuleList::addModuleInteractive (const String& moduleID)
{
ModuleList list;
list.scanGlobalJuceModulePath();
if (auto* info = list.getModuleWithID (moduleID))
{
addModule (info->moduleFolder, areMostModulesCopiedLocally(), areMostModulesUsingGlobalPath());
return;
}
list.scanGlobalUserModulePath();
if (auto* info = list.getModuleWithID (moduleID))
{
addModule (info->moduleFolder, areMostModulesCopiedLocally(), areMostModulesUsingGlobalPath());
return;
}
list.scanProjectExporterModulePaths (project);
if (auto* info = list.getModuleWithID (moduleID))
addModule (info->moduleFolder, areMostModulesCopiedLocally(), false);
else
addModuleFromUserSelectedFile();
}
//*************************************************************************
// Method: fillModuleListPSAPI
// Description: support function
//
//*************************************************************************
bool StackWalker::fillModuleListPSAPI( ModuleList& modules, DWORD pid, HANDLE hProcess )
{
// EnumProcessModules()
typedef BOOL (__stdcall *tEPM)( HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded );
// GetModuleFileNameEx()
typedef DWORD (__stdcall *tGMFNE)( HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize );
// GetModuleBaseName() -- redundant, as GMFNE() has the same prototype, but who cares?
typedef DWORD (__stdcall *tGMBN)( HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize );
// GetModuleInformation()
typedef BOOL (__stdcall *tGMI)( HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize );
HINSTANCE hPsapi;
tEPM pEPM;
tGMFNE pGMFNE;
tGMBN pGMBN;
tGMI pGMI;
int i;
ModuleEntry e;
DWORD cbNeeded;
MODULEINFO mi;
HMODULE *hMods = 0;
char *tt = 0;
hPsapi = LoadLibrary( "psapi.dll" );
if ( hPsapi == 0 )
return false;
modules.clear();
pEPM = (tEPM) GetProcAddress( hPsapi, "EnumProcessModules" );
pGMFNE = (tGMFNE) GetProcAddress( hPsapi, "GetModuleFileNameExA" );
pGMBN = (tGMFNE) GetProcAddress( hPsapi, "GetModuleBaseNameA" );
pGMI = (tGMI) GetProcAddress( hPsapi, "GetModuleInformation" );
if ( pEPM == 0 || pGMFNE == 0 || pGMBN == 0 || pGMI == 0 )
{
// yuck. Some API is missing.
FreeLibrary( hPsapi );
return false;
}
hMods = new HMODULE[TTBUFLEN / sizeof HMODULE];
tt = new char[TTBUFLEN];
// not that this is a sample. Which means I can get away with
// not checking for errors, but you cannot. :)
if ( ! pEPM( hProcess, hMods, TTBUFLEN, &cbNeeded ) )
{
//printf( "EPM failed, GetLastError() = %lu\n", GetLastError() );
goto cleanup;
}
if ( cbNeeded > TTBUFLEN )
{
//printf( "More than %lu module handles. Huh?\n", lenof( hMods ) );
goto cleanup;
}
for ( i = 0; i < cbNeeded / sizeof hMods[0]; ++ i )
{
// for each module, get:
// base address, size
pGMI( hProcess, hMods[i], &mi, sizeof mi );
e.baseAddress = (DWORD) mi.lpBaseOfDll;
e.size = mi.SizeOfImage;
// image file name
tt[0] = '\0';
pGMFNE( hProcess, hMods[i], tt, TTBUFLEN );
e.imageName = tt;
// module name
tt[0] = '\0';
pGMBN( hProcess, hMods[i], tt, TTBUFLEN );
e.moduleName = tt;
/*printf( "%08lXh %6lu %-15.15s %s\n", e.baseAddress,
e.size, e.moduleName.c_str(), e.imageName.c_str() );*/
modules.push_back( e );
}
cleanup:
if ( hPsapi )
FreeLibrary( hPsapi );
delete [] tt;
delete [] hMods;
return modules.size() != 0;
}
void
Breakpoint::ModulesChanged (ModuleList &module_list, bool load)
{
if (load)
{
// The logic for handling new modules is:
// 1) If the filter rejects this module, then skip it.
// 2) Run through the current location list and if there are any locations
// for that module, we mark the module as "seen" and we don't try to re-resolve
// breakpoint locations for that module.
// However, we do add breakpoint sites to these locations if needed.
// 3) If we don't see this module in our breakpoint location list, call ResolveInModules.
ModuleList new_modules; // We'll stuff the "unseen" modules in this list, and then resolve
// them after the locations pass. Have to do it this way because
// resolving breakpoints will add new locations potentially.
const size_t num_locs = m_locations.GetSize();
for (size_t i = 0; i < module_list.GetSize(); i++)
{
bool seen = false;
ModuleSP module_sp (module_list.GetModuleAtIndex (i));
if (!m_filter_sp->ModulePasses (module_sp))
continue;
for (size_t loc_idx = 0; loc_idx < num_locs; loc_idx++)
{
BreakpointLocationSP break_loc = m_locations.GetByIndex(loc_idx);
if (!break_loc->IsEnabled())
continue;
const Section *section = break_loc->GetAddress().GetSection();
if (section == NULL || section->GetModule() == module_sp.get())
{
if (!seen)
seen = true;
if (!break_loc->ResolveBreakpointSite())
{
LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
if (log)
log->Printf ("Warning: could not set breakpoint site for breakpoint location %d of breakpoint %d.\n",
break_loc->GetID(), GetID());
}
}
}
if (!seen)
new_modules.AppendIfNeeded (module_sp);
}
if (new_modules.GetSize() > 0)
{
ResolveBreakpointInModules(new_modules);
}
}
else
{
// Go through the currently set locations and if any have breakpoints in
// the module list, then remove their breakpoint sites.
// FIXME: Think about this... Maybe it's better to delete the locations?
// Are we sure that on load-unload-reload the module pointer will remain
// the same? Or do we need to do an equality on modules that is an
// "equivalence"???
for (size_t i = 0; i < module_list.GetSize(); i++)
{
ModuleSP module_sp (module_list.GetModuleAtIndex (i));
if (m_filter_sp->ModulePasses (module_sp))
{
const size_t num_locs = m_locations.GetSize();
for (size_t loc_idx = 0; loc_idx < num_locs; ++loc_idx)
{
BreakpointLocationSP break_loc = m_locations.GetByIndex(loc_idx);
const Section *section = break_loc->GetAddress().GetSection();
if (section && section->GetModule() == module_sp.get())
{
// Remove this breakpoint since the shared library is
// unloaded, but keep the breakpoint location around
// so we always get complete hit count and breakpoint
// lifetime info
break_loc->ClearBreakpointSite();
}
}
}
}
}
}
//*************************************************************************
// Method: fillModuleListTH32
// Description: support function
//
//*************************************************************************
bool StackWalker::fillModuleListTH32( ModuleList& modules, DWORD pid )
{
// CreateToolhelp32Snapshot()
typedef HANDLE (__stdcall *tCT32S)( DWORD dwFlags, DWORD th32ProcessID );
// Module32First()
typedef BOOL (__stdcall *tM32F)( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
// Module32Next()
typedef BOOL (__stdcall *tM32N)( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
// I think the DLL is called tlhelp32.dll on Win9X, so we try both
const char *dllname[] = { "kernel32.dll", "tlhelp32.dll" };
HINSTANCE hToolhelp;
tCT32S pCT32S;
tM32F pM32F;
tM32N pM32N;
HANDLE hSnap;
MODULEENTRY32 me = { sizeof me };
bool keepGoing;
ModuleEntry e;
int i;
for ( i = 0; i < lenof( dllname ); ++ i )
{
hToolhelp = LoadLibrary( dllname[i] );
if ( hToolhelp == 0 )
continue;
pCT32S = (tCT32S) GetProcAddress( hToolhelp, "CreateToolhelp32Snapshot" );
pM32F = (tM32F) GetProcAddress( hToolhelp, "Module32First" );
pM32N = (tM32N) GetProcAddress( hToolhelp, "Module32Next" );
if ( pCT32S != 0 && pM32F != 0 && pM32N != 0 )
break; // found the functions!
FreeLibrary( hToolhelp );
hToolhelp = 0;
}
if ( hToolhelp == 0 ) // nothing found?
return false;
hSnap = pCT32S( TH32CS_SNAPMODULE, pid );
if ( hSnap == (HANDLE) -1 )
return false;
keepGoing = !!pM32F( hSnap, &me );
while ( keepGoing )
{
// here, we have a filled-in MODULEENTRY32
//printf( "%08lXh %6lu %-15.15s %s\n", me.modBaseAddr, me.modBaseSize, me.szModule, me.szExePath );
e.imageName = me.szExePath;
e.moduleName = me.szModule;
e.baseAddress = (DWORD) me.modBaseAddr;
e.size = me.modBaseSize;
modules.push_back( e );
keepGoing = !!pM32N( hSnap, &me );
}
CloseHandle( hSnap );
FreeLibrary( hToolhelp );
return modules.size() != 0;
}
void *__hxcpp_get_proc_address(String inLib, String full_name,bool inNdllProc,bool inQuietFail)
{
String bin = __hxcpp_get_bin_dir();
String deviceExt = __hxcpp_get_dll_extension();
#ifdef HX_ANDROID
String module_name = HX_CSTRING("lib") + inLib;
#else
String module_name = inLib;
#endif
#ifdef IPHONE
gLoadDebug = true;
setenv("DYLD_PRINT_APIS","1",true);
#elif !defined(HX_WINRT)
gLoadDebug = gLoadDebug || getenv("HXCPP_LOAD_DEBUG");
#endif
if (!sgLibPathIsInit)
{
sgLibPathIsInit = true;
sgLibPath.push_back("./");
#ifdef HX_MACOS
sgLibPath.push_back("@executable_path/");
#endif
sgLibPath.push_back("");
#ifdef HXCPP_TRY_HAXELIB
String hxcpp = GetEnv("HXCPP");
if (hxcpp.length==0)
hxcpp = FindHaxelib( HX_CSTRING("hxcpp") );
if (hxcpp.length!=0)
__hxcpp_push_dll_path(hxcpp+HX_CSTRING("/bin/") + bin + HX_CSTRING("/"));
#endif
}
Module module = sgLoadedModule[module_name.__s];
bool new_module = module==0;
if (!module && sgRegisteredPrims)
{
void *registered = (*sgRegisteredPrims)[full_name.__CStr()];
// Try with lib name ...
if (!registered)
{
String libString = inLib + HX_CSTRING("_") + full_name;
registered = (*sgRegisteredPrims)[libString.__CStr()];
}
if (registered)
return registered;
}
if (!module && gLoadDebug)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_INFO, "loader", "Searching for %s...", module_name.__s);
#else
printf("Searching for %s...\n", inLib.__s);
#endif
}
String haxelibPath;
for(int e=0; module==0 && e<3; e++)
{
String extension = e==0 ? deviceExt : e==1 ? HX_CSTRING(".ndll") : HX_CSTRING("");
for(int path=0;path<sgLibPath.size();path++)
{
String testPath = String( sgLibPath[path].c_str() ) + module_name + extension;
if (gLoadDebug)
{
#ifndef ANDROID
printf(" try %s...\n", testPath.__s);
#else
__android_log_print(ANDROID_LOG_INFO, "loader", "Try %s", testPath.__s);
#endif
}
module = hxLoadLibrary(testPath);
if (module)
{
if (gLoadDebug)
{
#ifndef ANDROID
printf("Found %s\n", testPath.__s);
#else
__android_log_print(ANDROID_LOG_INFO, "loader", "Found %s", testPath.__s);
#endif
}
break;
}
}
#ifdef HXCPP_TRY_HAXELIB
if (!module)
{
if (e==0)
haxelibPath = FindHaxelib(inLib);
if (haxelibPath.length!=0)
{
String testPath = haxelibPath + HX_CSTRING("/ndll/") + bin + HX_CSTRING("/") + inLib + extension;
if (gLoadDebug)
printf(" try %s...\n", testPath.__s);
module = hxLoadLibrary(testPath);
if (module && gLoadDebug)
{
printf("Found %s\n", testPath.__s);
}
}
}
#endif
}
if (!module)
{
hx::Throw(HX_CSTRING("Could not load module ") + inLib + HX_CSTRING("@") + full_name);
}
if (new_module)
{
sgLoadedModule[module_name.__s] = module;
sgOrderedModules.push_back(module);
SetLoaderProcFunc set_loader = (SetLoaderProcFunc)hxFindSymbol(module,"hx_set_loader");
if (set_loader)
set_loader(hx_cffi);
GetNekoEntryFunc func = (GetNekoEntryFunc)hxFindSymbol(module,"__neko_entry_point");
if (func)
{
NekoEntryFunc entry = (NekoEntryFunc)func();
if (entry)
entry();
}
}
FundFunc proc_query = (FundFunc)hxFindSymbol(module,full_name.__CStr());
if (!proc_query)
proc_query = (FundFunc)hxFindSymbol(module, (inLib + HX_CSTRING("_") + full_name).__CStr());
if (!proc_query && !inQuietFail)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_ERROR, "loader", "Could not find primitive %s in %p",
full_name.__CStr(), module);
#else
fprintf(stderr,"Could not find primitive %s.\n", full_name.__CStr());
#endif
return 0;
}
if (!inNdllProc)
return (void *)proc_query;
void *proc = proc_query();
if (!proc && !inQuietFail)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_ERROR, "loader", "Could not identify primitive %s in %s",
full_name.__CStr(), inLib.__CStr() );
#else
fprintf(stderr,"Could not identify primitive %s in %s\n", full_name.__CStr(),inLib.__CStr());
#endif
}
return proc;
}
void Breakpoint::ModulesChanged(ModuleList &module_list, bool load,
bool delete_locations) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
if (log)
log->Printf("Breakpoint::ModulesChanged: num_modules: %zu load: %i "
"delete_locations: %i\n",
module_list.GetSize(), load, delete_locations);
std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
if (load) {
// The logic for handling new modules is:
// 1) If the filter rejects this module, then skip it.
// 2) Run through the current location list and if there are any locations
// for that module, we mark the module as "seen" and we don't try to
// re-resolve
// breakpoint locations for that module.
// However, we do add breakpoint sites to these locations if needed.
// 3) If we don't see this module in our breakpoint location list, call
// ResolveInModules.
ModuleList new_modules; // We'll stuff the "unseen" modules in this list,
// and then resolve
// them after the locations pass. Have to do it this way because
// resolving breakpoints will add new locations potentially.
for (ModuleSP module_sp : module_list.ModulesNoLocking()) {
bool seen = false;
if (!m_filter_sp->ModulePasses(module_sp))
continue;
for (BreakpointLocationSP break_loc_sp :
m_locations.BreakpointLocations()) {
if (!break_loc_sp->IsEnabled())
continue;
SectionSP section_sp(break_loc_sp->GetAddress().GetSection());
if (!section_sp || section_sp->GetModule() == module_sp) {
if (!seen)
seen = true;
if (!break_loc_sp->ResolveBreakpointSite()) {
if (log)
log->Printf("Warning: could not set breakpoint site for "
"breakpoint location %d of breakpoint %d.\n",
break_loc_sp->GetID(), GetID());
}
}
}
if (!seen)
new_modules.AppendIfNeeded(module_sp);
}
if (new_modules.GetSize() > 0) {
ResolveBreakpointInModules(new_modules);
}
} else {
// Go through the currently set locations and if any have breakpoints in
// the module list, then remove their breakpoint sites, and their locations
// if asked to.
BreakpointEventData *removed_locations_event;
if (!IsInternal())
removed_locations_event = new BreakpointEventData(
eBreakpointEventTypeLocationsRemoved, shared_from_this());
else
removed_locations_event = nullptr;
size_t num_modules = module_list.GetSize();
for (size_t i = 0; i < num_modules; i++) {
ModuleSP module_sp(module_list.GetModuleAtIndexUnlocked(i));
if (m_filter_sp->ModulePasses(module_sp)) {
size_t loc_idx = 0;
size_t num_locations = m_locations.GetSize();
BreakpointLocationCollection locations_to_remove;
for (loc_idx = 0; loc_idx < num_locations; loc_idx++) {
BreakpointLocationSP break_loc_sp(m_locations.GetByIndex(loc_idx));
SectionSP section_sp(break_loc_sp->GetAddress().GetSection());
if (section_sp && section_sp->GetModule() == module_sp) {
// Remove this breakpoint since the shared library is
// unloaded, but keep the breakpoint location around
// so we always get complete hit count and breakpoint
// lifetime info
break_loc_sp->ClearBreakpointSite();
if (removed_locations_event) {
removed_locations_event->GetBreakpointLocationCollection().Add(
break_loc_sp);
}
if (delete_locations)
locations_to_remove.Add(break_loc_sp);
}
}
if (delete_locations) {
size_t num_locations_to_remove = locations_to_remove.GetSize();
for (loc_idx = 0; loc_idx < num_locations_to_remove; loc_idx++)
m_locations.RemoveLocation(locations_to_remove.GetByIndex(loc_idx));
}
}
}
SendBreakpointChangedEvent(removed_locations_event);
}
}
void
JITLoaderMono::ProcessEntry (uint32_t type, const addr_t addr, int64_t size)
{
ModuleSP module_sp;
Target &target = m_process->GetTarget();
ModuleList &module_list = target.GetImages();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
switch (type) {
case ENTRY_CODE_REGION:
//
// This entry defines a code region in the JIT.
// We represent it using an lldb module.
// The entry starts with a magic string so ReadModuleFromMemory ()
// will create an ObjectFileMono object for it.
//
char jit_name[64];
snprintf(jit_name, 64, "Mono");
module_sp = m_process->ReadModuleFromMemory(
FileSpec(jit_name, false), addr, size);
if (module_sp && module_sp->GetObjectFile()) {
bool changed;
ObjectFileMono *ofile = (ObjectFileMono*)module_sp->GetObjectFile ();
module_sp->GetObjectFile()->GetSymtab();
module_list.AppendIfNeeded(module_sp);
module_sp->SetLoadAddress(target, 0, true, changed);
ModuleList mlist;
mlist.Append(module_sp);
target.ModulesDidLoad(mlist);
m_regions [ofile->GetId ()] = ofile;
} else {
if (log)
log->Printf("JITLoaderMono::%s failed to load module for "
"JIT entry at 0x%" PRIx64,
__FUNCTION__, addr);
}
break;
case ENTRY_UNLOAD_CODE_REGION: {
uint8_t *buf = new uint8_t [size];
Error error;
UnloadCodeRegionEntry *entry = (UnloadCodeRegionEntry*)buf;
m_process->ReadMemory (addr, buf, size, error);
assert (!error.Fail ());
auto iter = m_regions.find (entry->id);
assert (iter != m_regions.end ());
ObjectFileMono *ofile = (ObjectFileMono*)iter->second;
ModuleList mlist;
mlist.Append(ofile->GetModule ());
target.ModulesDidUnload(mlist, true);
break;
}
case ENTRY_METHOD: {
uint8_t *buf = new uint8_t [size];
Error error;
m_process->ReadMemory (addr, buf, size, error);
assert (!error.Fail ());
int region_id = ObjectFileMono::GetMethodEntryRegion(buf, size);
auto iter = m_regions.find (region_id);
assert (iter != m_regions.end ());
ObjectFileMono *ofile = (ObjectFileMono*)iter->second;
ofile->AddMethod (buf, size);
// This is needed so breakpoints can be resolved
ModuleList mlist;
mlist.Append (ofile->GetModule ());
target.ModulesDidLoad (mlist);
break;
}
case ENTRY_TRAMPOLINE: {
uint8_t *buf = new uint8_t [size];
Error error;
m_process->ReadMemory (addr, buf, size, error);
assert (!error.Fail ());
int region_id = ObjectFileMono::GetTrampolineEntryRegion(buf, size);
auto iter = m_regions.find (region_id);
assert (iter != m_regions.end ());
ObjectFileMono *ofile = (ObjectFileMono*)iter->second;
ofile->AddTrampoline (buf, size);
break;
}
default:
if (log)
log->Printf("JITLoaderMono::%s unknown entry type %d", __FUNCTION__, type);
break;
}
}
void ProjectExporter::createPropertyEditors (PropertyListBuilder& props)
{
props.add (new TextPropertyComponent (getTargetLocationValue(), "Target Project Folder", 1024, false),
"The location of the folder in which the " + name + " project will be created. "
"This path can be absolute, but it's much more sensible to make it relative to the jucer project directory.");
props.add (new TextPropertyComponent (getJuceFolderValue(), "Local JUCE folder", 1024, false),
"The location of the Juce library folder that the " + name + " project will use to when compiling. "
"This can be an absolute path, or relative to the jucer project folder, but it must be valid on the "
"filesystem of the machine you use to actually do the compiling.");
OwnedArray<LibraryModule> modules;
ModuleList moduleList;
moduleList.rescan (ModuleList::getDefaultModulesFolder (&project));
project.createRequiredModules (moduleList, modules);
for (int i = 0; i < modules.size(); ++i)
modules.getUnchecked(i)->createPropertyEditors (*this, props);
props.add (new TextPropertyComponent (getExporterPreprocessorDefs(), "Extra Preprocessor Definitions", 32768, true),
"Extra preprocessor definitions. Use the form \"NAME1=value NAME2=value\", using whitespace, commas, "
"or new-lines to separate the items - to include a space or comma in a definition, precede it with a backslash.");
props.add (new TextPropertyComponent (getExtraCompilerFlags(), "Extra compiler flags", 2048, true),
"Extra command-line flags to be passed to the compiler. This string can contain references to preprocessor definitions in the "
"form ${NAME_OF_DEFINITION}, which will be replaced with their values.");
props.add (new TextPropertyComponent (getExtraLinkerFlags(), "Extra linker flags", 2048, true),
"Extra command-line flags to be passed to the linker. You might want to use this for adding additional libraries. "
"This string can contain references to preprocessor definitions in the form ${NAME_OF_VALUE}, which will be replaced with their values.");
props.add (new TextPropertyComponent (getExternalLibraries(), "External libraries to link", 2048, true),
"Additional libraries to link (one per line). You should not add any platform specific decoration to these names. "
"This string can contain references to preprocessor definitions in the form ${NAME_OF_VALUE}, which will be replaced with their values.");
{
OwnedArray<Project::Item> images;
project.findAllImageItems (images);
StringArray choices;
Array<var> ids;
choices.add ("<None>");
ids.add (var::null);
choices.add (String::empty);
ids.add (var::null);
for (int i = 0; i < images.size(); ++i)
{
choices.add (images.getUnchecked(i)->getName());
ids.add (images.getUnchecked(i)->getID());
}
props.add (new ChoicePropertyComponent (getSmallIconImageItemID(), "Icon (small)", choices, ids),
"Sets an icon to use for the executable.");
props.add (new ChoicePropertyComponent (getBigIconImageItemID(), "Icon (large)", choices, ids),
"Sets an icon to use for the executable.");
}
createExporterProperties (props);
props.add (new TextPropertyComponent (getUserNotes(), "Notes", 32768, true),
"Extra comments: This field is not used for code or project generation, it's just a space where you can express your thoughts.");
}
bool fillModuleListPSAPI( ModuleList& modules, DWORD pid, HANDLE hProcess )
{
// EnumProcessModules()
typedef BOOL (__stdcall *tEPM)( HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded );
// GetModuleFileNameEx()
typedef DWORD (__stdcall *tGMFNE)( HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize );
// GetModuleBaseName() -- redundant, as GMFNE() has the same prototype, but who cares?
typedef DWORD (__stdcall *tGMBN)( HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize );
// GetModuleInformation()
typedef BOOL (__stdcall *tGMI)( HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize );
HINSTANCE hPsapi;
tEPM pEPM;
tGMFNE pGMFNE;
tGMBN pGMBN;
tGMI pGMI;
DWORD i;
ModuleEntry e;
DWORD cbNeeded;
MODULEINFO mi;
HMODULE *hMods = 0;
char *tt = 0;
GString g("psapi.dll");
hPsapi = LoadLibrary( g );
if ( hPsapi == 0 )
return false;
modules.clear();
pEPM = (tEPM) GetProcAddress( hPsapi, "EnumProcessModules" );
pGMFNE = (tGMFNE) GetProcAddress( hPsapi, "GetModuleFileNameExA" );
pGMBN = (tGMFNE) GetProcAddress( hPsapi, "GetModuleBaseNameA" );
pGMI = (tGMI) GetProcAddress( hPsapi, "GetModuleInformation" );
if ( pEPM == 0 || pGMFNE == 0 || pGMBN == 0 || pGMI == 0 )
{
FreeLibrary( hPsapi );
return false;
}
hMods = new HMODULE[TTBUFLEN / sizeof(HMODULE)];
tt = new char[TTBUFLEN];
// check for errors and cleanup
if ( ! pEPM( hProcess, hMods, TTBUFLEN, &cbNeeded ) )
{
goto cleanup;
}
if ( cbNeeded > TTBUFLEN )
{
goto cleanup;
}
for ( i = 0; i < cbNeeded / sizeof hMods[0]; ++ i )
{
// for each module, get:
// base address, size
pGMI( hProcess, hMods[i], &mi, sizeof mi );
e.baseAddress = (DWORD) mi.lpBaseOfDll;
e.size = mi.SizeOfImage;
// image file name
tt[0] = '\0';
pGMFNE( hProcess, hMods[i], tt, TTBUFLEN );
e.imageName = tt;
// module name
tt[0] = '\0';
pGMBN( hProcess, hMods[i], tt, TTBUFLEN );
e.moduleName = tt;
modules.push_back( e );
}
cleanup:
if ( hPsapi )
FreeLibrary( hPsapi );
delete [] tt;
delete [] hMods;
return modules.size() != 0;
}
int main(int argc, char** argv) {
using namespace Sirikata;
DynamicLibrary::Initialize();
InitOptions();
Trace::Trace::InitOptions();
SpaceTrace::InitOptions();
InitSpaceOptions();
ParseOptions(argc, argv, OPT_CONFIG_FILE, AllowUnregisteredOptions);
PluginManager plugins;
plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) );
plugins.loadList( GetOptionValue<String>(OPT_EXTRA_PLUGINS) );
plugins.loadList( GetOptionValue<String>(OPT_SPACE_PLUGINS) );
plugins.loadList( GetOptionValue<String>(OPT_SPACE_EXTRA_PLUGINS) );
// Fill defaults after plugin loading to ensure plugin-added
// options get their defaults.
FillMissingOptionDefaults();
// Rerun original parse to make sure any newly added options are
// properly parsed.
ParseOptions(argc, argv, OPT_CONFIG_FILE);
DaemonizeAndSetOutputs();
ReportVersion(); // After options so log goes to the right place
std::string time_server=GetOptionValue<String>("time-server");
NTPTimeSync sync;
if (time_server.size() > 0)
sync.start(time_server);
ServerID server_id = GetOptionValue<ServerID>("id");
String trace_file = GetPerServerFile(STATS_TRACE_FILE, server_id);
Sirikata::Trace::Trace* gTrace = new Trace::Trace(trace_file);
// Compute the starting date/time
String start_time_str = GetOptionValue<String>("wait-until");
Time start_time = start_time_str.empty() ? Timer::now() : Timer::getSpecifiedDate( start_time_str );
start_time += GetOptionValue<Duration>("wait-additional");
Duration duration = GetOptionValue<Duration>("duration");
Network::IOService* ios = new Network::IOService("Space");
Network::IOStrand* mainStrand = ios->createStrand("Space Main");
ODPSST::ConnectionManager* sstConnMgr = new ODPSST::ConnectionManager();
OHDPSST::ConnectionManager* ohSstConnMgr = new OHDPSST::ConnectionManager();
SpaceContext* space_context = new SpaceContext("space", server_id, sstConnMgr, ohSstConnMgr, ios, mainStrand, start_time, gTrace, duration);
String servermap_type = GetOptionValue<String>("servermap");
String servermap_options = GetOptionValue<String>("servermap-options");
ServerIDMap * server_id_map =
ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(space_context, servermap_options);
space_context->add(space_context);
String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES);
String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS);
Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(space_context, timeseries_options);
String commander_type = GetOptionValue<String>(OPT_COMMAND_COMMANDER);
String commander_options = GetOptionValue<String>(OPT_COMMAND_COMMANDER_OPTIONS);
Command::Commander* commander = NULL;
if (!commander_type.empty())
commander = Command::CommanderFactory::getSingleton().getConstructor(commander_type)(space_context, commander_options);
Transfer::TransferMediator::getSingleton().registerContext(space_context);
Sirikata::SpaceNetwork* gNetwork = NULL;
String network_type = GetOptionValue<String>(NETWORK_TYPE);
if (network_type == "tcp")
gNetwork = new TCPSpaceNetwork(space_context);
BoundingBox3f region = GetOptionValue<BoundingBox3f>("region");
Vector3ui32 layout = GetOptionValue<Vector3ui32>("layout");
srand( GetOptionValue<uint32>("rand-seed") );
ObjectHostSessionManager* oh_sess_mgr = new ObjectHostSessionManager(space_context);
ObjectSessionManager* obj_sess_mgr = new ObjectSessionManager(space_context);
String auth_type = GetOptionValue<String>(SPACE_OPT_AUTH);
String auth_opts = GetOptionValue<String>(SPACE_OPT_AUTH_OPTIONS);
Authenticator* auth =
AuthenticatorFactory::getSingleton().getConstructor(auth_type)(space_context, auth_opts);
gNetwork->setServerIDMap(server_id_map);
Forwarder* forwarder = new Forwarder(space_context);
String cseg_type = GetOptionValue<String>(CSEG);
CoordinateSegmentation* cseg = NULL;
if (cseg_type == "uniform")
cseg = new UniformCoordinateSegmentation(space_context, region, layout);
else if (cseg_type == "client") {
cseg = new CoordinateSegmentationClient(space_context, region, layout, server_id_map);
}
else {
assert(false);
exit(-1);
}
String loc_update_type = GetOptionValue<String>(LOC_UPDATE);
String loc_update_opts = GetOptionValue<String>(LOC_UPDATE_OPTIONS);
LocationUpdatePolicy* loc_update_policy =
LocationUpdatePolicyFactory::getSingleton().getConstructor(loc_update_type)(space_context, loc_update_opts);
String loc_service_type = GetOptionValue<String>(LOC);
String loc_service_opts = GetOptionValue<String>(LOC_OPTIONS);
LocationService* loc_service =
LocationServiceFactory::getSingleton().getConstructor(loc_service_type)(space_context, loc_update_policy, loc_service_opts);
ServerMessageQueue* sq = NULL;
String server_queue_type = GetOptionValue<String>(SERVER_QUEUE);
if (server_queue_type == "fair") {
sq = new FairServerMessageQueue(
space_context, gNetwork,
(ServerMessageQueue::Sender*)forwarder);
}
else {
assert(false);
exit(-1);
}
ServerMessageReceiver* server_message_receiver = NULL;
String server_receiver_type = GetOptionValue<String>(SERVER_RECEIVER);
if (server_queue_type == "fair")
server_message_receiver =
new FairServerMessageReceiver(space_context, gNetwork, (ServerMessageReceiver::Listener*)forwarder);
else {
assert(false);
exit(-1);
}
LoadMonitor* loadMonitor = new LoadMonitor(space_context, cseg);
// OSeg Cache
OSegCache* oseg_cache = NULL;
std::string cacheSelector = GetOptionValue<String>(CACHE_SELECTOR);
uint32 cacheSize = GetOptionValue<uint32>(OSEG_CACHE_SIZE);
if (cacheSelector == CACHE_TYPE_COMMUNICATION) {
double cacheCommScaling = GetOptionValue<double>(CACHE_COMM_SCALING);
oseg_cache = new CommunicationCache(space_context, cacheCommScaling, cseg, cacheSize);
}
else if (cacheSelector == CACHE_TYPE_ORIGINAL_LRU) {
uint32 cacheCleanGroupSize = GetOptionValue<uint32>(OSEG_CACHE_CLEAN_GROUP_SIZE);
Duration entryLifetime = GetOptionValue<Duration>(OSEG_CACHE_ENTRY_LIFETIME);
oseg_cache = new CacheLRUOriginal(space_context, cacheSize, cacheCleanGroupSize, entryLifetime);
}
else {
std::cout<<"\n\nUNKNOWN CACHE TYPE SELECTED. Please re-try.\n\n";
std::cout.flush();
assert(false);
}
//Create OSeg
std::string oseg_type = GetOptionValue<String>(OSEG);
std::string oseg_options = GetOptionValue<String>(OSEG_OPTIONS);
Network::IOStrand* osegStrand = space_context->ioService->createStrand("OSeg");
ObjectSegmentation* oseg =
OSegFactory::getSingleton().getConstructor(oseg_type)(space_context, osegStrand, cseg, oseg_cache, oseg_options);
//end create oseg
// We have all the info to initialize the forwarder now
forwarder->initialize(oseg, sq, server_message_receiver, loc_service);
String aggmgr_hostname = GetOptionValue<String>(OPT_AGGMGR_HOSTNAME);
String aggmgr_service = GetOptionValue<String>(OPT_AGGMGR_SERVICE);
String aggmgr_consumer_key = GetOptionValue<String>(OPT_AGGMGR_CONSUMER_KEY);
String aggmgr_consumer_secret = GetOptionValue<String>(OPT_AGGMGR_CONSUMER_SECRET);
String aggmgr_access_key = GetOptionValue<String>(OPT_AGGMGR_ACCESS_KEY);
String aggmgr_access_secret = GetOptionValue<String>(OPT_AGGMGR_ACCESS_SECRET);
String aggmgr_username = GetOptionValue<String>(OPT_AGGMGR_USERNAME);
Transfer::OAuthParamsPtr aggmgr_oauth;
// Currently you need to explicitly override hostname to enable upload
if (!aggmgr_hostname.empty()&&
!aggmgr_consumer_key.empty() && !aggmgr_consumer_secret.empty() &&
!aggmgr_access_key.empty() && !aggmgr_access_secret.empty()) {
aggmgr_oauth = Transfer::OAuthParamsPtr(
new Transfer::OAuthParams(
aggmgr_hostname, aggmgr_service,
aggmgr_consumer_key, aggmgr_consumer_secret,
aggmgr_access_key, aggmgr_access_secret
)
);
}
std::string aggmgr_type = GetOptionValue<String>(OPT_AGGMGR);
AggregateManager* aggmgr = AggregateManagerFactory::getSingleton().getConstructor(aggmgr_type)(loc_service, aggmgr_oauth, aggmgr_username);
std::string prox_type = GetOptionValue<String>(OPT_PROX);
std::string prox_options = GetOptionValue<String>(OPT_PROX_OPTIONS);
Proximity* prox = ProximityFactory::getSingleton().getConstructor(prox_type)(space_context, loc_service, cseg, gNetwork, aggmgr, prox_options);
// We need to do an async lookup, and to finish it the server needs to be
// running. But we can't create the server until we have the address from
// this lookup. We isolate as little as possible into this callback --
// creating the server, finishing prox initialization, and getting them both
// registered. We pass storage for the Server to the callback so we can
// handle cleaning it up ourselves.
using std::tr1::placeholders::_1;
using std::tr1::placeholders::_2;
Server* server = NULL;
ModuleList modules;
ServerData sd;
sd.space_context = space_context;
sd.auth = auth;
sd.forwarder = forwarder;
sd.loc_service = loc_service;
sd.cseg = cseg;
sd.prox = prox;
sd.oseg = oseg;
sd.oh_sess_mgr = oh_sess_mgr;
sd.obj_sess_mgr = obj_sess_mgr;
server_id_map->lookupExternal(
space_context->id(),
space_context->mainStrand->wrap(
std::tr1::bind( &createServer, &server, &modules, sd, _1, _2)
)
);
// If we're one of the initial nodes, we'll have to wait until we hit the start time
{
Time now_time = Timer::now();
if (start_time > now_time) {
Duration sleep_time = start_time - now_time;
printf("Waiting %f seconds\n", sleep_time.toSeconds() ); fflush(stdout);
Timer::sleep(sleep_time);
}
}
///////////Go go go!! start of simulation/////////////////////
space_context->add(auth);
space_context->add(gNetwork);
space_context->add(cseg);
space_context->add(loc_service);
space_context->add(oseg);
space_context->add(loadMonitor);
space_context->add(sstConnMgr);
space_context->add(ohSstConnMgr);
space_context->add(prox);
space_context->run(3);
space_context->cleanup();
if (GetOptionValue<bool>(PROFILE)) {
space_context->profiler->report();
}
gTrace->prepareShutdown();
Mesh::FilterFactory::destroy();
ModelsSystemFactory::destroy();
LocationServiceFactory::destroy();
LocationUpdatePolicyFactory::destroy();
for(ModuleList::iterator it = modules.begin(); it != modules.end(); it++)
delete *it;
modules.clear();
delete server;
delete sq;
delete server_message_receiver;
delete prox;
delete aggmgr;
delete server_id_map;
delete loadMonitor;
delete cseg;
delete oseg;
delete oseg_cache;
delete loc_service;
delete forwarder;
delete obj_sess_mgr;
delete oh_sess_mgr;
delete gNetwork;
gNetwork=NULL;
gTrace->shutdown();
delete gTrace;
gTrace = NULL;
delete commander;
delete space_context;
space_context = NULL;
delete time_series;
delete mainStrand;
delete osegStrand;
delete ios;
delete sstConnMgr;
delete ohSstConnMgr;
Transfer::TransferMediator::destroy();
sync.stop();
plugins.gc();
Sirikata::Logging::finishLog();
DaemonCleanup();
return 0;
}
namespace lyx {
//global variable: module list
ModuleList theModuleList;
LyXModule::LyXModule(string const & n, string const & i,
string const & d, vector<string> const & p,
vector<string> const & r, vector<string> const & e,
string const & c, bool const local):
name_(n), id_(i), description_(d), package_list_(p),
required_modules_(r), excluded_modules_(e), category_(c),
checked_(false), available_(false), local_(local)
{
filename_ = id_ + ".module";
}
vector<string> LyXModule::prerequisites() const
{
if (!checked_)
isAvailable();
return prerequisites_;
}
bool LyXModule::isAvailable() const
{
if (package_list_.empty())
return true;
if (checked_)
return available_;
checked_ = true;
available_ = true;
//check whether all of the required packages are available
vector<string>::const_iterator it = package_list_.begin();
vector<string>::const_iterator end = package_list_.end();
for (; it != end; ++it) {
if (!LaTeXFeatures::isAvailable(*it)) {
available_ = false;
prerequisites_.push_back(*it);
}
}
return available_;
}
bool LyXModule::isCompatible(string const & modname) const
{
// do we exclude it?
if (find(excluded_modules_.begin(), excluded_modules_.end(), modname) !=
excluded_modules_.end())
return false;
LyXModule const * const lm = theModuleList[modname];
if (!lm)
return true;
// does it exclude us?
vector<string> const excmods = lm->getExcludedModules();
if (find(excmods.begin(), excmods.end(), id_) != excmods.end())
return false;
return true;
}
bool LyXModule::areCompatible(string const & mod1, string const & mod2)
{
LyXModule const * const lm1 = theModuleList[mod1];
if (lm1)
return lm1->isCompatible(mod2);
LyXModule const * const lm2 = theModuleList[mod2];
if (lm2)
return lm2->isCompatible(mod1);
// Can't check it either way.
return true;
}
// used when sorting the module list.
class ModuleSorter {
public:
int operator()(LyXModule const & lm1, LyXModule const & lm2) const
{
return _(lm1.getName()) < _(lm2.getName());
}
};
// Much of this is borrowed from LayoutFileList::read()
bool ModuleList::read()
{
FileName const real_file = libFileSearch("", "lyxmodules.lst");
LYXERR(Debug::TCLASS, "Reading modules from `" << real_file << '\'');
if (real_file.empty()) {
LYXERR0("unable to find modules file `lyxmodules.lst'.\n"
<< "No modules will be available.");
return false;
}
Lexer lex;
if (!lex.setFile(real_file)) {
LYXERR0("lyxlex was not able to set file: "
<< real_file << ".\nNo modules will be available.");
return false;
}
if (!lex.isOK()) {
LYXERR0("unable to open modules file `"
<< to_utf8(makeDisplayPath(real_file.absFileName(), 1000))
<< "'\nNo modules will be available.");
return false;
}
bool finished = false;
// Parse modules files
LYXERR(Debug::TCLASS, "Starting parsing of lyxmodules.lst");
while (lex.isOK() && !finished) {
LYXERR(Debug::TCLASS, "\tline by line");
switch (lex.lex()) {
case Lexer::LEX_FEOF:
finished = true;
break;
default:
string const modname = lex.getString();
LYXERR(Debug::TCLASS, "Module name: " << modname);
if (!lex.next())
break;
string const fname = lex.getString();
LYXERR(Debug::TCLASS, "Filename: " << fname);
if (!lex.next(true))
break;
string const desc = lex.getString();
LYXERR(Debug::TCLASS, "Description: " << desc);
//FIXME Add packages
if (!lex.next())
break;
string str = lex.getString();
LYXERR(Debug::TCLASS, "Packages: " << str);
vector<string> pkgs;
while (!str.empty()) {
string p;
str = split(str, p, ',');
pkgs.push_back(p);
}
if (!lex.next())
break;
str = lex.getString();
LYXERR(Debug::TCLASS, "Required: " << str);
vector<string> req;
while (!str.empty()) {
string p;
str = split(str, p, '|');
req.push_back(p);
}
if (!lex.next())
break;
str = lex.getString();
LYXERR(Debug::TCLASS, "Excluded: " << str);
vector<string> exc;
while (!str.empty()) {
string p;
str = split(str, p, '|');
exc.push_back(p);
}
if (!lex.next())
break;
string const catgy = lex.getString();
LYXERR(Debug::TCLASS, "Category: " << catgy);
if (!lex.next())
break;
bool const local = lex.getString() == "true";
LYXERR(Debug::TCLASS, "Local: " << local);
// This code is run when we have
// modName, fname, desc, pkgs, req, exc, catgy, and local
addLayoutModule(modname, fname, desc, pkgs, req, exc, catgy, local);
} // end switch
} //end while
LYXERR(Debug::TCLASS, "End of parsing of lyxmodules.lst");
if (!theModuleList.empty())
sort(theModuleList.begin(), theModuleList.end(), ModuleSorter());
return true;
}
void ModuleList::addLayoutModule(string const & modname,
string const & filename, string const & description,
vector<string> const & pkgs, vector<string> const & req,
vector<string> const & exc, string const & catgy, bool const local)
{
LyXModule lm(modname, filename, description, pkgs, req, exc, catgy, local);
modlist_.push_back(lm);
}
LyXModuleList::const_iterator ModuleList::begin() const
{
return modlist_.begin();
}
LyXModuleList::iterator ModuleList::begin()
{
return modlist_.begin();
}
LyXModuleList::const_iterator ModuleList::end() const
{
return modlist_.end();
}
LyXModuleList::iterator ModuleList::end()
{
return modlist_.end();
}
LyXModule const * ModuleList::operator[](string const & str) const
{
LyXModuleList::const_iterator it = modlist_.begin();
for (; it != modlist_.end(); ++it)
if (it->getID() == str) {
LyXModule const & mod = *it;
return &mod;
}
return 0;
}
LyXModule * ModuleList::operator[](string const & str)
{
LyXModuleList::iterator it = modlist_.begin();
for (; it != modlist_.end(); ++it)
if (it->getID() == str) {
LyXModule & mod = *it;
return &mod;
}
return 0;
}
} // namespace lyx
