void
ThreadQueue::wakeup()
{
// we traverse the list in reverse orders and use indices. This should be
// robust for scripts that add new entries to the list while we're traversing
// it
size_t i = threads.size() - 1;
size_t end = static_cast<size_t>(0 - 1);
size_t size_begin = threads.size();
while(i != end) {
HSQOBJECT object = threads[i];
sq_pushobject(global_vm, object);
sq_getweakrefval(global_vm, -1);
HSQUIRRELVM scheduled_vm;
if(sq_gettype(global_vm, -1) == OT_THREAD &&
SQ_SUCCEEDED(sq_getthread(global_vm, -1, &scheduled_vm))) {
if(SQ_FAILED(sq_wakeupvm(scheduled_vm, SQFalse, SQFalse, SQTrue, SQFalse))) {
log_warning << "Couldn't wakeup scheduled squirrel VM" << std::endl;
}
}
sq_release(global_vm, &object);
sq_pop(global_vm, 1);
i--;
}
threads.erase(threads.begin(), threads.begin() + size_begin);
}
void run(char *conf_file) {
struct running rr;
struct event *sig1_ev,*sig2_ev,*sig_hup;
evthread_use_pthreads();
setup_running(&rr);
register_interface_types(&rr);
register_source_types(&rr);
run_config(&rr,conf_file);
start_stats_timer(&rr);
ref_release(&(rr.ic_running));
event_add(sq_consumer(rr.sq),0);
event_add(si_consumer(rr.si),0);
sq_release(rr.sq);
evsignal_add(sig1_ev=evsignal_new(rr.eb,SIGINT,user_quit,&rr),0);
evsignal_add(sig2_ev=evsignal_new(rr.eb,SIGTERM,user_quit,&rr),0);
evsignal_add(sig_hup=evsignal_new(rr.eb,SIGHUP,hupev,&rr),0);
rr.sigkill_timer = event_new(rr.eb,-1,EV_PERSIST,sigkill_self,&rr);
log_info(("Starting event loop"));
event_base_loop(rr.eb,0);
log_info(("Event loop finished"));
event_del(sig1_ev);
event_del(sig2_ev);
event_del(sig_hup);
event_free(sig1_ev);
event_free(sig2_ev);
event_free(sig_hup);
closedown(&rr);
log_info(("Bye!"));
config_finished();
}
void SquirrelThread::initThread(HSQUIRRELVM parentVm)
{
m_oldTop = -1;
m_parentVm = parentVm;
createThread();
// create a local environment for the m_thread
HSQOBJECT env;
sq_resetobject(&env);
sq_newtable(m_thread);
// store the object in env
if(sq_getstackobj(m_thread, -1, &env) < 0)
{ return; }
sq_addref(m_thread, &env);
sq_pop(m_thread, 1); // remove env from stack
// set old roottable as delegate on env
sq_pushobject(m_thread, env); // push env
sq_pushroottable(m_thread); // [env, root]
sq_setdelegate(m_thread, -2); // env.set_delegate(root)
sq_pop(m_thread, 1); // pop env
// set env as new roottable
sq_pushobject(m_thread, env);
sq_setroottable(m_thread);
sq_release(m_thread, &env);
}
bool CEvents::RemoveEvent(CString strName, CEventHandler::eEventType eventType, IScriptVM* pVM){
for (std::map<CString, std::list<CEventHandler*>>::iterator iter = m_Events.begin(); iter != m_Events.end(); iter++){
if ((*iter).first.Compare(strName) == 0){
for (std::list< CEventHandler* >::iterator iter2 = (*iter).second.begin(); iter2 != (*iter).second.end(); iter2++){
if (eventType == CEventHandler::RESOURCE_EVENT && pVM == (*iter2)->GetVM()){
if ((*iter2)->GetVM()->GetVMType() == eVMType::LUA_VM)
{
//TODO: Remove Lua event
}
else if ((*iter2)->GetVM()->GetVMType() == eVMType::SQUIRREL_VM)
{
sq_release(((CSquirrelVM*)pVM)->GetVM(), &(*iter2)->GetFunction());
(*iter).second.erase(iter2);
// Remove events with no handlers
if ((*iter).second.size() == 0)
m_Events.erase(iter);
return true;
}
}
else if ((*iter2)->GetType() == eventType && pVM == nullptr){
(*iter).second.erase(iter2);
// Remove events with no handlers
if ((*iter).second.size() == 0)
m_Events.erase(iter);
return true;
}
}
}
}
return false;
}
void
TimeScheduler::update(float time)
{
while(!schedule.empty() && schedule.front().wakeup_time < time) {
HSQOBJECT thread_ref = schedule.front().thread_ref;
sq_pushobject(global_vm, thread_ref);
sq_getweakrefval(global_vm, -1);
HSQUIRRELVM scheduled_vm;
if(sq_gettype(global_vm, -1) == OT_THREAD &&
SQ_SUCCEEDED(sq_getthread(global_vm, -1, &scheduled_vm))) {
if(SQ_FAILED(sq_wakeupvm(scheduled_vm, SQFalse, SQFalse, SQTrue, SQFalse))) {
std::ostringstream msg;
msg << "Error waking VM: ";
sq_getlasterror(scheduled_vm);
if(sq_gettype(scheduled_vm, -1) != OT_STRING) {
msg << "(no info)";
} else {
const char* lasterr;
sq_getstring(scheduled_vm, -1, &lasterr);
msg << lasterr;
}
log_warning << msg.str() << std::endl;
sq_pop(scheduled_vm, 1);
}
}
sq_release(global_vm, &thread_ref);
sq_pop(global_vm, 2);
std::pop_heap(schedule.begin(), schedule.end());
schedule.pop_back();
}
}
SQDbgServer::~SQDbgServer()
{
sq_release(_v,&_debugroot);
if(_accept != INVALID_SOCKET)
sqdbg_closesocket(_accept);
if(_endpoint != INVALID_SOCKET)
sqdbg_closesocket(_endpoint);
}
void SquirrelThread::closeThread()
{
if (m_thread) {
//sq_close(m_thread);
sq_release(m_parentVm, &m_threadObj);
m_thread = NULL;
}
}
void SquirrelObject::AttachToStackObject(int idx)
{
HSQOBJECT t;
sq_getstackobj(m_Vm.GetVMPtr(),idx,&t);
sq_addref(m_Vm.GetVMPtr(),&t);
sq_release(m_Vm.GetVMPtr(),&_o);
_o = t;
}
SquirrelObject & SquirrelObject::operator =(const SquirrelObject &o)
{
HSQOBJECT t;
t = o._o;
sq_addref(m_Vm.GetVMPtr(),&t);
sq_release(m_Vm.GetVMPtr(),&_o);
_o = t;
return *this;
}
int main(void)
{
init_mat();
sq_matrix_revise();
sq_matrix_print();
sq_release();
return 0;
}
ScriptBehavior::~ScriptBehavior()
{
if( m_initialize )
{
if( m_haveAwake )
{
sq_release( m_vm,&m_awakeFunction );
}
if( m_haveStart )
{
sq_release( m_vm,&m_startFunction );
}
if( m_haveUpdate )
{
sq_release( m_vm,&m_updateFunction );
}
sq_release( m_vm,&m_instance );
}
}
SQDbgServer::~SQDbgServer()
{
VMStateMap::iterator itr = _vmstate.begin();
while (itr != _vmstate.end()) {
VMState *vs = itr->second;
delete vs;
++itr;
}
_vmstate.clear();
sq_pushobject(_v, _debugroot);
sq_clear(_v, -1);
sq_release(_v, &_debugroot);
if (_accept != INVALID_SOCKET)
sqdbg_closesocket(_accept);
if (_endpoint != INVALID_SOCKET)
sqdbg_closesocket(_endpoint);
}
bool CEvents::RemoveResourceEvents(IScriptVM* pVM){
for (std::map<CString, std::list<CEventHandler*>>::iterator iter = m_Events.begin(); iter != m_Events.end(); iter++){
for (std::list< CEventHandler* >::iterator iter2 = (*iter).second.begin(); iter2 != (*iter).second.end(); iter2++){
if ((*iter2)->GetVM() == pVM){
if ((*iter2)->GetVM()->GetVMType() == eVMType::LUA_VM)
{
//TODO: Remove Lua event
}
else if ((*iter2)->GetVM()->GetVMType() == eVMType::SQUIRREL_VM)
{
CLogFile::Printf("Deleting event %s...", (*iter).first.C_String());
CLogFile::Printf("Events before: %d", (*iter).second.size());
sq_release(((CSquirrelVM*)pVM)->GetVM(), &(*iter2)->GetFunction());
(*iter).second.erase(iter2--);
CLogFile::Printf("Event %s DELETED!!", (*iter).first.C_String());
CLogFile::Printf("Events after: %d", (*iter).second.size());
}
}
}
// Remove events with no handlers
if ((*iter).second.size() == 0){
CLogFile::Printf("Deleting %s empty...", (*iter).first.C_String());
m_Events.erase(iter);
CLogFile::Printf("Empty DELETED!!");
}
}
// Function for view all stored resources
for (std::map<CString, std::list<CEventHandler*>>::iterator iter = m_Events.begin(); iter != m_Events.end(); iter++){
CLogFile::Printf("----- Event %s: %d", (*iter).first.Get(), (*iter).second.size());
for (std::list< CEventHandler* >::iterator iter2 = (*iter).second.begin(); iter2 != (*iter).second.end(); iter2++){
if ((*iter2)->GetVM()->GetResource()->GetName().Get())
CLogFile::Printf("- Resource %s", (*iter2)->GetVM()->GetResource()->GetName().Get());
else
CLogFile::Printf("--- Error: unknown resource");
}
}
if (m_Events.size() == 0){
m_Events.clear();
CLogFile::Printf("There aren' events...");
}
return true;
}
SQRESULT sqrat_import(HSQUIRRELVM v) {
const SQChar* moduleName;
HSQOBJECT table;
SQRESULT res = SQ_OK;
SQInteger top = sq_gettop(v);
sq_getstring(v, -2, &moduleName);
sq_getstackobj(v, -1, &table);
sq_addref(v, &table);
sq_settop(v, 0); // Clear Stack
sq_pushobject(v, table); // Push the target table onto the stack
if(SQ_FAILED(sqrat_importscript(v, moduleName))) {
res = sqrat_importbin(v, moduleName);
}
sq_settop(v, 0); // Clean up the stack (just in case the module load leaves it messy)
sq_pushobject(v, table); // return the target table
sq_release(v, &table);
return res;
}
static void release_visitor_cb(MyLibClang *self)
{
sq_release(self->v, &self->visitor_cb);
sq_resetobject(&self->visitor_cb);
}
SquirrelObject::~SquirrelObject()
{
if(m_Vm.GetVMPtr())
sq_release(m_Vm.GetVMPtr(),&_o);
}
/**
* Release a SQ object.
*/
void ReleaseObject(HSQOBJECT *ptr) { sq_release(this->vm, ptr); }
void ScriptObject::reset(void)
{
sq_release(mSqvm, &mObj);
sq_resetobject(&mObj);
}
