SquirrelObject SquirrelObject::GetValue(const SQChar *key)/*const*/ { SquirrelObject ret; if(GetSlot(key)) { ret.AttachToStackObject(-1); sq_pop(m_Vm.GetVMPtr(),1); } sq_pop(m_Vm.GetVMPtr(),1); return ret; }
float SquirrelObject::GetFloat(const SQChar *key) /*const*/ { float ret = 0.0f; if(GetSlot(key)) { sq_getfloat(m_Vm.GetVMPtr(),-1,&ret); sq_pop(m_Vm.GetVMPtr(),1); } sq_pop(m_Vm.GetVMPtr(),1); return ret; }
const SQChar *SquirrelObject::GetString(int key) /*const*/ { const SQChar *ret = NULL; if(GetSlot(key)) { sq_getstring(m_Vm.GetVMPtr(),-1,&ret); sq_pop(m_Vm.GetVMPtr(),1); } sq_pop(m_Vm.GetVMPtr(),1); return ret; }
bool SquirrelObject::GetBool(int key) /*const*/ { SQBool ret = FALSE; if(GetSlot(key)) { sq_getbool(m_Vm.GetVMPtr(),-1,&ret); sq_pop(m_Vm.GetVMPtr(),1); } sq_pop(m_Vm.GetVMPtr(),1); return ret?true:false; }
int SquirrelObject::GetInt(int key) /*const*/ { int ret = 0; if(GetSlot(key)) { sq_getinteger(m_Vm.GetVMPtr(),-1,&ret); sq_pop(m_Vm.GetVMPtr(),1); } sq_pop(m_Vm.GetVMPtr(),1); return ret; }
SQInteger Sq_Interpolate(HSQUIRRELVM v) { const SQChar *Str, *WordString; char Out[4096]; sq_getstring(v, 2, &Str); sq_getstring(v, 3, &WordString); char *Poke = Out; const char *Peek = Str; char WordBuff[strlen(Str)+1]; const char *Word[32]; const char *WordEol[32]; XChatTokenize(WordString, WordBuff, Word, WordEol, 32, TOKENIZE_MULTI_WORD); while(*Peek) { int Span = strcspn(Peek, "%&"); memcpy(Poke, Peek, Span); Poke += Span; Peek += Span; if(*Peek == '%' || *Peek == '&') { char Extra = Peek[1]; if(Extra == '%') *(Poke++) = '%'; else if(Extra == '&') *(Poke++) = '&'; else { if(isdigit(Extra)) { int WhichWord = Extra - '1'; strcpy(Poke, (*Peek=='%')?Word[WhichWord]:WordEol[WhichWord]); Poke = strrchr(Poke, 0); } else { // look in the list of extra words int top = sq_gettop(v);; sq_pushnull(v); //null iterator while(SQ_SUCCEEDED(sq_next(v,-2))) { const SQChar *ThisWord; sq_getstring(v, -1, &ThisWord); if(ThisWord[0]==Extra) { strcpy(Poke, ThisWord+1); Poke = strrchr(Poke, 0); break; } sq_pop(v,2); } sq_pop(v,1); //pops the null iterator sq_settop(v, top); } } Peek+= 2; } } *Poke = 0; sq_pushstring(v, Out, -1); return 1; }
bool SQDbgServer::Init() { //creates an environment table for the debugger sq_newtable(_v); sq_getstackobj(_v,-1,&_debugroot); sq_addref(_v,&_debugroot); //creates a emptyslot to store the watches sq_pushstring(_v,_SC("watches"),-1); sq_pushnull(_v); sq_createslot(_v,-3); sq_pushstring(_v,_SC("beginelement"),-1); sq_pushuserpointer(_v,this); sq_newclosure(_v,beginelement,1); sq_setparamscheck(_v,2,_SC(".s")); sq_createslot(_v,-3); sq_pushstring(_v,_SC("endelement"),-1); sq_pushuserpointer(_v,this); sq_newclosure(_v,endelement,1); sq_setparamscheck(_v,2,_SC(".s")); sq_createslot(_v,-3); sq_pushstring(_v,_SC("attribute"),-1); sq_pushuserpointer(_v,this); sq_newclosure(_v,attribute,1); sq_setparamscheck(_v,3,_SC(".ss")); sq_createslot(_v,-3); sq_pop(_v,1); //stores debug hook and error handler in the registry sq_pushregistrytable(_v); sq_pushstring(_v,SQDBG_DEBUG_HOOK,-1); sq_pushuserpointer(_v,this); sq_newclosure(_v,debug_hook,1); sq_createslot(_v,-3); sq_pushstring(_v,SQDBG_ERROR_HANDLER,-1); sq_pushuserpointer(_v,this); sq_newclosure(_v,error_handler,1); sq_createslot(_v,-3); sq_pop(_v,1); //sets the error handlers SetErrorHandlers(); return true; }
/** * TJSオブジェクトのオーバライド処理 * 引数1 オブジェクト * 引数2 名前 * 引数3 値。省略時は squirrel インスタンスから名前で参照 */ SQRESULT TJSObject::tjsOverride(HSQUIRRELVM v) { SQRESULT result; tTJSVariant instance; if (getVariant(v,1,&instance) && instance.Type() == tvtObject) { tTJSVariant value; const SQChar *methodName = sqobject::getString(v,2); int n = sq_gettop(v); if (n >= 3) { // 引数で明示指定されている if (SQ_FAILED(result = sq_getvariant(v, 3, &value))) { return result; } } else { // 自己オブジェクトから名前で検索して登録 sq_push(v, 1); sq_pushstring(v, methodName, -1); if (SQ_FAILED(result = sq_get(v, -2))) { sq_pop(v, 1); //self return result; } else { SQObjectType type = sq_gettype(v, -1); if (type == OT_CLOSURE || type == OT_NATIVECLOSURE) { // クロージャの場合は bindenv しておく sq_push(v, 1); if (SQ_FAILED(result = sq_bindenv(v, -2))) { sq_pop(v, 2); // func, self return result; } else { sq_remove(v, -2); // original func } } if (SQ_FAILED(result = sq_getvariant(v, -1, &value))) { // value sq_pop(v, 1); //self return result; } sq_pop(v, 1); // self } } tjs_error error; if (TJS_SUCCEEDED(error = instance.AsObjectClosureNoAddRef().PropSet(TJS_MEMBERENSURE, methodName, NULL, &value, NULL))) { return SQ_OK; } else { return ERROR_KRKR(v, error); } } return ERROR_BADINSTANCE(v); }
void EventListener::ProcessEvent(Rocket::Core::Event& event) { HSQUIRRELVM vm = Module::instance().getScriptInterface().getSquirrelVM(); if (!mScript.IsCompiled()) { } mScript.Compile(vm, false); GlobalUtility gutil(vm, m_pElement->GetOwnerDocument(), m_pElement, &event); SQInteger i = sq_gettop(vm); SQRESULT sqr; gutil.Set(); Module::instance().getScriptInterface().PushDocumentTable(vm, m_pElement->GetOwnerDocument()); sqr = sq_bindenv(vm, i); ROCKETSQUIRREL_ASSERT(SQ_SUCCEEDED(sqr)); sq_pushroottable(vm); mScript.Run(vm); gutil.Restore(); sq_pop(vm, i); return; }
/* * get instance member value as float */ bool getInstanceMemberAsFloat(HSQUIRRELVM v, int idx, const char *name, SQFloat* value) { if (sq_gettype(v, idx) == OT_NULL) return false; sq_pushstring(v, name, -1); if (!SQ_SUCCEEDED(sq_get(v, idx))) { sq_pop(v, 1); return false; } if (sq_gettype(v, -1) == OT_NULL) { sq_pop(v, 1); return false; } sq_getfloat(v, -1, value); sq_pop(v, 1); return true; }
BOOL SbuCreateClass(HSQUIRRELVM v,SquirrelClassDecl *cd) { int n = 0; int oldtop = sq_gettop(v); sq_pushroottable(v); sq_pushstring(v,cd->name,-1); if(cd->base) { sq_pushstring(v,cd->base,-1); if(SQ_FAILED(sq_get(v,-3))) { sq_settop(v,oldtop); return FALSE; } } if(SQ_FAILED(sq_newclass(v,cd->base?1:0))) { sq_settop(v,oldtop); return FALSE; } sq_settypetag(v,-1,(SQUserPointer)cd); const ScriptClassMemberDecl *members = cd->members; const ScriptClassMemberDecl *m = NULL; while(members[n].name) { m = &members[n]; sq_pushstring(v,m->name,-1); sq_newclosure(v,m->func,0); sq_setparamscheck(v,m->params,m->typemask); sq_setnativeclosurename(v,-1,m->name); sq_createslot(v,-3); n++; } sq_createslot(v,-3); sq_pop(v,1); return TRUE; }
void BindInput() { Sqrat::Class<CInput, Sqrat::NoConstructor> def; def.Func("KeyUp", &CInput::KeyUp); def.Func("KeyPressed", &CInput::KeyPressed); def.Func("KeyHeld", &CInput::KeyHeld); def.Func("KeyReleased", &CInput::KeyReleased); Sqrat::RootTable().Bind("InputSystem", def); //Sqrat::ConstTable().Const("KEY_LEFT", KEY_LEFT); MAKE_KEY( KEY_LEFT ); MAKE_KEY( KEY_RIGHT ); MAKE_KEY( KEY_UP ); MAKE_KEY( KEY_DOWN ); MAKE_KEY( KEY_Q ); MAKE_KEY( KEY_W ); MAKE_KEY( KEY_PAGEUP ); MAKE_KEY( KEY_PAGEDOWN ); MAKE_KEY( KEY_HOME ); // Push the singleton to squirrel sq_pushroottable( Sqrat::DefaultVM::Get() ); sq_pushstring( Sqrat::DefaultVM::Get(), "InputSystem", -1 ); sq_get( Sqrat::DefaultVM::Get(), -2 ); sq_pushstring( Sqrat::DefaultVM::Get(), "Input", -1 ); sq_createinstance( Sqrat::DefaultVM::Get(), -2 ); sq_setinstanceup( Sqrat::DefaultVM::Get(), -1, (SQUserPointer)Input() ); sq_newslot( Sqrat::DefaultVM::Get(), -4, SQFalse ); sq_pop( Sqrat::DefaultVM::Get(), 2 ); }
int SquirrelScriptContext::SquirrelClassToStringMethodCallback(HSQUIRRELVM vm) { // Get class info MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER ); void* userPtr = NULL; sq_getuserpointer(vm, -1, &userPtr); sq_pop(vm, 1); SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr; // Get the instance MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE ); sq_getinstanceup(vm, 1, &userPtr, 0); SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr; MultiScriptAssert(scriptObject->m_objectPtr); // Invoke to-string method char buffer[1 << 8]; if (classInfo->m_desc->m_toStringMethod) { SquirrelScriptStack stack(classInfo->m_context, false); const bool result = classInfo->m_desc->m_toStringMethod(scriptObject, buffer, 1 << 8); MultiScriptAssert( result ); MultiScriptAssert( stack.m_numPushed == 0 ); } else MultiScriptSprintf(buffer, 1 << 8, "[%s]", classInfo->m_desc->m_name); sq_pushstring(vm, buffer, -1); return 1; }
HSQOBJECT class_init(HSQUIRRELVM v,SQFUNCTION c,const SQChar * p_name) { HSQOBJECT class_id; sq_pushroottable(v); sq_pushstring(v,p_name,-1); sq_newclass(v,SQFalse); sq_getstackobj(v,-1,&class_id); sq_settypetag(v,-1,&class_id); HSQOBJECT string_constructor; sq_pushstring(v,_SC("constructor"),-1); sq_resetobject(&string_constructor); sq_getstackobj(v,-1,&string_constructor); sq_newclosure(v,c,0); sq_newslot(v,-3,false); sq_pushstring(v,_SC("_cloned"),-1); sq_newclosure(v,clone<T>,0); sq_newslot(v,-3,false); sq_newslot(v,-3,false); sq_pop(v,1); return class_id; }
/** Run the dummy info.nut. */ void Script_CreateDummyInfo(HSQUIRRELVM vm, const char *type, const char *dir) { char dummy_script[4096]; char *dp = dummy_script; dp += seprintf(dp, lastof(dummy_script), "class Dummy%s extends %sInfo {\n", type, type); dp += seprintf(dp, lastof(dummy_script), "function GetAuthor() { return \"OpenTTD Developers Team\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetName() { return \"Dummy%s\"; }\n", type); dp += seprintf(dp, lastof(dummy_script), "function GetShortName() { return \"DUMM\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetDescription() { return \"A Dummy %s that is loaded when your %s/ dir is empty\"; }\n", type, dir); dp += seprintf(dp, lastof(dummy_script), "function GetVersion() { return 1; }\n"); dp += seprintf(dp, lastof(dummy_script), "function GetDate() { return \"2008-07-26\"; }\n"); dp += seprintf(dp, lastof(dummy_script), "function CreateInstance() { return \"Dummy%s\"; }\n", type); dp += seprintf(dp, lastof(dummy_script), "} RegisterDummy%s(Dummy%s());\n", type, type); const SQChar *sq_dummy_script = dummy_script; sq_pushroottable(vm); /* Load and run the script */ if (SQ_SUCCEEDED(sq_compilebuffer(vm, sq_dummy_script, strlen(sq_dummy_script), "dummy", SQTrue))) { sq_push(vm, -2); if (SQ_SUCCEEDED(sq_call(vm, 1, SQFalse, SQTrue))) { sq_pop(vm, 1); return; } } NOT_REACHED(); }
void sq_base_register(HSQUIRRELVM v) { SQInteger i=0; sq_pushroottable(v); while(base_funcs[i].name!=0) { sq_pushstring(v,base_funcs[i].name,-1); sq_newclosure(v,base_funcs[i].f,0); sq_setnativeclosurename(v,-1,base_funcs[i].name); sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask); sq_createslot(v,-3); i++; } sq_pushstring(v,_SC("_version_"),-1); sq_pushstring(v,SQUIRREL_VERSION,-1); sq_createslot(v,-3); sq_pushstring(v,_SC("_charsize_"),-1); sq_pushinteger(v,sizeof(SQChar)); sq_createslot(v,-3); sq_pushstring(v,_SC("_intsize_"),-1); sq_pushinteger(v,sizeof(SQInteger)); sq_createslot(v,-3); sq_pushstring(v,_SC("_floatsize_"),-1); sq_pushinteger(v,sizeof(SQFloat)); sq_createslot(v,-3); sq_pop(v,1); }
void SQDbgServer::SerializeState() { sq_pushnull(_v); sq_setdebughook(_v); sq_pushnull(_v); sq_seterrorhandler(_v); const SQChar *sz; sq_pushobject(_v,_serializefunc); sq_pushobject(_v,_debugroot); sq_pushstring(_v,_SC("watches"),-1); sq_newtable(_v); for(WatchSetItor i=_watches.begin(); i!=_watches.end(); ++i) { sq_pushinteger(_v,i->_id); sq_pushstring(_v,i->_exp.c_str(),(int)i->_exp.length()); sq_createslot(_v,-3); } sq_rawset(_v,-3); if(SQ_SUCCEEDED(sq_call(_v,1,SQTrue,SQTrue))){ if(SQ_SUCCEEDED(sqstd_getblob(_v,-1,(SQUserPointer*)&sz))) SendChunk(sz); } sq_pop(_v,2); SetErrorHandlers(); }
bool has_float(HSQUIRRELVM vm, const char* name) { sq_pushstring(vm, name, -1); if (SQ_FAILED(sq_get(vm, -2))) return false; sq_pop(vm, 1); return true; }
static SQInteger thread_wakeup(HSQUIRRELVM v) { SQObjectPtr o = stack_get(v,1); if(type(o) == OT_THREAD) { SQVM *thread = _thread(o); SQInteger state = sq_getvmstate(thread); if(state != SQ_VMSTATE_SUSPENDED) { switch(state) { case SQ_VMSTATE_IDLE: return sq_throwerror(v,_SC("cannot wakeup a idle thread")); break; case SQ_VMSTATE_RUNNING: return sq_throwerror(v,_SC("cannot wakeup a running thread")); break; } } SQInteger wakeupret = sq_gettop(v)>1?1:0; if(wakeupret) { sq_move(thread,v,2); } if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) { sq_move(v,thread,-1); sq_pop(thread,1); //pop retval if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) { sq_settop(thread,1); //pop roottable } return 1; } sq_settop(thread,1); v->_lasterror = thread->_lasterror; return SQ_ERROR; } return sq_throwerror(v,_SC("wrong parameter")); }
SquirrelObject & SquirrelObject::operator =(int n) { sq_pushinteger(m_Vm.GetVMPtr(),n); AttachToStackObject(-1); sq_pop(m_Vm.GetVMPtr(),1); return *this; }
ScriptText::ScriptText(HSQUIRRELVM vm) : ZeroedMemoryAllocator() { int nparam = sq_gettop(vm) - 1; if (nparam < 1) { throw sq_throwerror(vm, _SC("You need to pass at least a StringID to the constructor")); } /* First resolve the StringID. */ SQInteger sqstring; if (SQ_FAILED(sq_getinteger(vm, 2, &sqstring))) { throw sq_throwerror(vm, _SC("First argument must be a valid StringID")); } this->string = sqstring; /* The rest of the parameters must be arguments. */ for (int i = 0; i < nparam - 1; i++) { /* Push the parameter to the top of the stack. */ sq_push(vm, i + 3); if (SQ_FAILED(this->_SetParam(i, vm))) { this->~ScriptText(); throw sq_throwerror(vm, _SC("Invalid parameter")); } /* Pop the parameter again. */ sq_pop(vm, 1); } }
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 SqEnv::reset() { AutoLock a(&_m); sq_pop(*_vm, 1); sq_close(*this->_vm); this->_init(); }
/* * Register global function. * Must be called before loading script files */ void register_global_func(HSQUIRRELVM v, SQFUNCTION func, const char *fname) { sq_pushroottable(v); sq_pushstring(v, fname, -1); sq_newclosure(v, func, 0); sq_createslot(v, -3); sq_pop(v,1); }
int SquirrelScriptContext::SquirrelClassConstructorCallback(HSQUIRRELVM vm) { MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER ); // Get class info void* userPtr = NULL; sq_getuserpointer(vm, -1, &userPtr); sq_pop(vm, 1); SquirrelClassInfo* classInfo = (SquirrelClassInfo*) userPtr; // Construct object SquirrelScriptObject* scriptObject = new SquirrelScriptObject(); scriptObject->m_classInfo = classInfo; SquirrelScriptStack stack(classInfo->m_context, false); classInfo->m_desc->m_constructor(&stack, scriptObject); MultiScriptAssert( scriptObject->m_objectPtr ); MultiScriptAssert( stack.m_numPushed == 0 ); // There is already an instance on the stack (pushed automatically when constructor was invoked from script) // Attach our object to created instance sq_setinstanceup(vm, -1, scriptObject); // Set garbage collection callback for this instance sq_setreleasehook(vm, -1, SquirrelClassGCCallback); return 0; }
/* * Register new class. * Must be called before loading script files */ void register_class(HSQUIRRELVM v, const char *cname) { sq_pushroottable(v); sq_pushstring(v, cname, -1); sq_newclass(v, false); sq_createslot(v, -3); sq_pop(v, 1); }
int main(int argc, char* argv[]) { HSQUIRRELVM v; v = sq_open(1024); // creates a VM with initial stack size 1024 //REGISTRATION OF STDLIB //sq_pushroottable(v); //push the root table where the std function will be registered //sqstd_register_iolib(v); //registers a library // ... call here other stdlibs string,math etc... //sq_pop(v,1); //pops the root table //END REGISTRATION OF STDLIB sqstd_seterrorhandlers(v); //registers the default error handlers sq_setprintfunc(v, printfunc,errorfunc); //sets the print function sq_pushroottable(v); //push the root table(were the globals of the script will be stored) if(SQ_SUCCEEDED(sqstd_dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any { call_foo(v,1,2.5,_SC("teststring")); } sq_pop(v,1); //pops the root table sq_close(v); return 0; }
/* * Register new table. * Must be called before loading script files */ void register_table(HSQUIRRELVM v, const char *name) { sq_pushroottable(v); sq_pushstring(v, name, -1); sq_newtable(v); sq_createslot(v, -3); sq_pop(v, 1); }
int main(void) { StackQueue* sq = sq_create(10); printf("Create: "); sq_print(sq); printf("Push: "); sq_push(sq, 5); sq_print(sq); printf("Enqueue: "); sq_enqueue(sq, 6); sq_print(sq); printf("Push: "); sq_push(sq, 7); sq_print(sq); printf("Popped: %u ", sq_pop(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); // Extra printf("Push: "); sq_push(sq, 1); sq_print(sq); printf("Push: "); sq_push(sq, 2); sq_print(sq); printf("Push: "); sq_push(sq, 3); sq_print(sq); printf("Push: "); sq_push(sq, 4); sq_print(sq); printf("Push: "); sq_push(sq, 5); sq_print(sq); printf("Push: "); sq_push(sq, 6); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); printf("Dequeued: %u ", sq_dequeue(sq)); sq_print(sq); sq_destroy(sq); return EXIT_SUCCESS; }
void CSquirrel::RegisterFunction(const char * szFunctionName, SQFUNCTION pfnFunction, int iParameterCount, const char * szFunctionTemplate, bool bPushRootTable) { // Push the root table onto the stack if needed if(bPushRootTable) sq_pushroottable(m_pVM); // Push the function name onto the stack sq_pushstring(m_pVM, szFunctionName, -1); // Create a new function sq_newclosure(m_pVM, pfnFunction, 0); // Set the function parameter template and count if(iParameterCount != -1) { char szTemp[128]; if(szFunctionTemplate) sprintf(szTemp, ".%s", szFunctionTemplate); sq_setparamscheck(m_pVM, (iParameterCount + 1), (szFunctionTemplate) ? szTemp : NULL); } // Create a new slot sq_createslot(m_pVM, -3); // Pop the root table from the stack if needed if(bPushRootTable) sq_pop(m_pVM, 1); }