// ------------------------------------------------------------------------
void ServersManager::setJoinedServer(uint32_t id)
{
MutexLocker(m_joined_server);
delete m_joined_server.getData();
// It's a copy!
m_joined_server.getData() = new Server(*getServerByID(id));
} // setJoinedServer
// -------------------------------------------------------------------------------- //
void guTuneInRadioProvider::EndReadStationsThread( void )
{
wxMutexLocker MutexLocker( m_ReadStationsThreadMutex );
m_ReadStationsThread = NULL;
// m_RadioPanel->EndLoadingStations();
wxCommandEvent Event( wxEVT_MENU, ID_RADIO_LOADING_STATIONS_FINISHED );
wxPostEvent( m_RadioPanel, Event );
}
// -------------------------------------------------------------------------------- //
void guTuneInRadioProvider::CancellSearchStations( void )
{
wxMutexLocker MutexLocker( m_ReadStationsThreadMutex );
if( m_ReadStationsThread )
{
m_ReadStationsThread->Pause();
m_ReadStationsThread->Delete();
m_ReadStationsThread = NULL;
}
}
void ciMethodData::load_extra_data() {
MethodData* mdo = get_MethodData();
MutexLocker(mdo->extra_data_lock());
// speculative trap entries also hold a pointer to a Method so need to be translated
DataLayout* dp_src = mdo->extra_data_base();
DataLayout* end_src = mdo->args_data_limit();
DataLayout* dp_dst = extra_data_base();
for (;; dp_src = MethodData::next_extra(dp_src), dp_dst = MethodData::next_extra(dp_dst)) {
assert(dp_src < end_src, "moved past end of extra data");
assert(((intptr_t)dp_dst) - ((intptr_t)extra_data_base()) == ((intptr_t)dp_src) - ((intptr_t)mdo->extra_data_base()), "source and destination don't match");
// New traps in the MDO may have been added since we copied the
// data (concurrent deoptimizations before we acquired
// extra_data_lock above) or can be removed (a safepoint may occur
// in the translate_from call below) as we translate the copy:
// update the copy as we go.
int tag = dp_src->tag();
if (tag != DataLayout::arg_info_data_tag) {
memcpy(dp_dst, dp_src, ((intptr_t)MethodData::next_extra(dp_src)) - ((intptr_t)dp_src));
}
switch(tag) {
case DataLayout::speculative_trap_data_tag: {
ciSpeculativeTrapData* data_dst = new ciSpeculativeTrapData(dp_dst);
SpeculativeTrapData* data_src = new SpeculativeTrapData(dp_src);
data_dst->translate_from(data_src);
#ifdef ASSERT
SpeculativeTrapData* data_src2 = new SpeculativeTrapData(dp_src);
assert(data_src2->method() == data_src->method() && data_src2->bci() == data_src->bci(), "entries changed while translating");
#endif
break;
}
case DataLayout::bit_data_tag:
break;
case DataLayout::no_tag:
case DataLayout::arg_info_data_tag:
// An empty slot or ArgInfoData entry marks the end of the trap data
return;
default:
fatal(err_msg("bad tag = %d", dp_dst->tag()));
}
}
}
/** Initialize Lua state.
* Initializes the state and makes all necessary initializations.
* @return fresh initialized Lua state
*/
lua_State *
LuaContext::init_state()
{
lua_State *L = luaL_newstate();
luaL_openlibs(L);
if (__enable_tracebacks) {
lua_getglobal(L, "debug");
lua_getfield(L, -1, "traceback");
lua_remove(L, -2);
}
// Add package paths
for (__slit = __package_dirs.begin(); __slit != __package_dirs.end(); ++__slit) {
do_string(L, "package.path = package.path .. \";%s/?.lua;%s/?/init.lua\"", __slit->c_str(), __slit->c_str());
}
for (__slit = __cpackage_dirs.begin(); __slit != __cpackage_dirs.end(); ++__slit) {
do_string(L, "package.cpath = package.cpath .. \";%s/?.so\"", __slit->c_str());
}
// load base packages
for (__slit = __packages.begin(); __slit != __packages.end(); ++__slit) {
do_string(L, "require(\"%s\")", __slit->c_str());
}
for ( __utit = __usertypes.begin(); __utit != __usertypes.end(); ++__utit) {
tolua_pushusertype(L, __utit->second.first, __utit->second.second.c_str());
lua_setglobal(L, __utit->first.c_str());
}
for ( __strings_it = __strings.begin(); __strings_it != __strings.end(); ++__strings_it) {
lua_pushstring(L, __strings_it->second.c_str());
lua_setglobal(L, __strings_it->first.c_str());
}
for ( __booleans_it = __booleans.begin(); __booleans_it != __booleans.end(); ++__booleans_it) {
lua_pushboolean(L, __booleans_it->second);
lua_setglobal(L, __booleans_it->first.c_str());
}
for ( __numbers_it = __numbers.begin(); __numbers_it != __numbers.end(); ++__numbers_it) {
lua_pushnumber(L, __numbers_it->second);
lua_setglobal(L, __numbers_it->first.c_str());
}
for ( __integers_it = __integers.begin(); __integers_it != __integers.end(); ++__integers_it) {
lua_pushinteger(L, __integers_it->second);
lua_setglobal(L, __integers_it->first.c_str());
}
LuaContext *tmpctx = new LuaContext(L);
MutexLocker(__watchers.mutex());
LockList<LuaContextWatcher *>::iterator i;
for (i = __watchers.begin(); i != __watchers.end(); ++i) {
try {
(*i)->lua_restarted(tmpctx);
} catch (...) {
delete tmpctx;
lua_close(L);
throw;
}
}
delete tmpctx;
if ( __start_script ) {
if (access(__start_script, R_OK) == 0) {
// it's a file and we can access it, execute it!
do_file(L, __start_script);
} else {
do_string(L, "require(\"%s\")", __start_script);
}
}
return L;
}
// ------------------------------------------------------------------------
ServersManager::~ServersManager()
{
cleanUpServers();
MutexLocker(m_joined_server);
delete m_joined_server.getData();
} // ~ServersManager
// ------------------------------------------------------------------------
void ServersManager::sort(bool sort_desc)
{
MutexLocker(m_sorted_servers);
m_sorted_servers.getData().insertionSort(0, sort_desc);
} // sort
// ------------------------------------------------------------------------
const Server* ServersManager::getServerByID (uint32_t id) const
{
MutexLocker(m_mapped_servers);
return m_mapped_servers.getData().at(id);
} // getServerByID
// ------------------------------------------------------------------------
const Server* ServersManager::getServerBySort (int index) const
{
MutexLocker(m_sorted_servers);
return m_sorted_servers.getData().get(index);
} // getServerBySort
// ------------------------------------------------------------------------
int ServersManager::getNumServers () const
{
MutexLocker(m_sorted_servers);
return m_sorted_servers.getData().size();
} // getNumServers
// ------------------------------------------------------------------------
void ServersManager::unsetJoinedServer()
{
MutexLocker(m_joined_server);
delete m_joined_server.getData();
m_joined_server.getData() = NULL;
} // unsetJoinedServer
