int endelement(HSQUIRRELVM v) { SQUserPointer up; const SQChar *name; sq_getuserpointer(v,-1,&up); SQDbgServer *self = (SQDbgServer*)up; sq_getuserpointer(v,-1,&up); sq_getstring(v,2,&name); self->EndElement(name); return 0; }
int attribute(HSQUIRRELVM v) { SQUserPointer up; const SQChar *name,*value; sq_getuserpointer(v,-1,&up); SQDbgServer *self = (SQDbgServer*)up; sq_getuserpointer(v,-1,&up); sq_getstring(v,2,&name); sq_getstring(v,3,&value); self->Attribute(name,value); return 0; }
int SquirrelScriptContext::SquirrelClassMethodCallback(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 method index MultiScriptAssert( sq_gettype(vm, -1) == OT_INTEGER ); int methodIndex; sq_getinteger(vm, -1, &methodIndex); sq_pop(vm, 1); // Get the instance MultiScriptAssert( sq_gettype(vm, 1) == OT_INSTANCE ); sq_getinstanceup(vm, 1, &userPtr, 0); SquirrelScriptObject* scriptObject = (SquirrelScriptObject*) userPtr; MultiScriptAssert(scriptObject->m_objectPtr); SquirrelScriptStack stack(classInfo->m_context, false); const bool result = classInfo->m_desc->m_methods[methodIndex].m_method(scriptObject, &stack); MultiScriptAssert( result ); return stack.m_numPushed; }
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; }
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; }
SQInteger quit(HSQUIRRELVM v) { int *done; sq_getuserpointer(v,-1,(SQUserPointer*)&done); *done=1; return 0; }
static SQInteger _file_constructor(HSQUIRRELVM v) { const SQChar *filename,*mode; bool owns = true; SQFile *f; SQFILE newf; if(sq_gettype(v,2) == OT_STRING && sq_gettype(v,3) == OT_STRING) { sq_getstring(v, 2, &filename); sq_getstring(v, 3, &mode); newf = sqstd_fopen(filename, mode); if(!newf) return sq_throwerror(v, _SC("cannot open file")); } else if(sq_gettype(v,2) == OT_USERPOINTER) { owns = !(sq_gettype(v,3) == OT_NULL); sq_getuserpointer(v,2,&newf); } else { return sq_throwerror(v,_SC("wrong parameter")); } f = new SQFile(newf,owns); if(SQ_FAILED(sq_setinstanceup(v,1,f))) { delete f; return sq_throwerror(v, _SC("cannot create blob with negative size")); } sq_setreleasehook(v,1,_file_releasehook); return 0; }
static SQInteger _mod_fclose(HSQUIRRELVM v) { SQUserPointer pd = 0; sq_getuserpointer(v, 2, &pd); if(pd) { fclose((FILE*)pd); } return 1; }
static SQInteger _mod_ftell(HSQUIRRELVM v) { SQUserPointer pf = 0; sq_getuserpointer(v, 2, &pf); if(pf) { sq_pushinteger(v, ftell((FILE*)pf)); return 1; } return -1; }
static SQInteger _mod_fwrite(HSQUIRRELVM v) { SQUserPointer pf = 0; const SQChar* data; sq_getuserpointer(v, 2, &pf); sq_getstring(v, 3, &data); if(pf) { return (SQInteger)fprintf((FILE*)pf,"%s", data); } return 0; }
CEntity* sq_toentity(SQVM* pVM, int idx) { SQUserPointer ptr; if(SQ_SUCCEEDED(sq_getuserpointer(pVM,idx,&ptr))) { CEntity* pEntity = CEntityIDs::Get( (int)ptr ); if( pEntity ) return pEntity; } return NULL; }
static SQRESULT squirrel_get_allocator(HSQUIRRELVM v, WasmAllocator** out_allocator) { SQUserPointer allocator_up; sq_pushregistrytable(v); sq_pushstring(v, WASM_ALLOCATOR_NAME, -1); CHECK_SQ_RESULT(sq_get(v, -2)); CHECK_SQ_RESULT(sq_getuserpointer(v, -1, &allocator_up)); *out_allocator = allocator_up; sq_pop(v, 2); return SQ_OK; }
static SQInteger _mod_fsize(HSQUIRRELVM v) { SQUserPointer pf = 0; sq_getuserpointer(v, 2, &pf); if(pf) { struct stat stt; if(fstat(fileno((FILE*)pf), &stt)) { sq_pushinteger(v, stt.st_size); return stt.st_size; } } return -1; }
static SQInteger sq_ffi_sym(HSQUIRRELVM v) { void *mod; const SQChar *symname; sq_getuserpointer(v, 2, &mod); sq_getstring(v, 3, &symname); void *sym = GET_SYM(mod, symname); printf("GET_SYM(%s) = %p\n", symname, sym); if (!sym) return sq_throwerror(v, "Cannot find symbol"); void **p = (void**)sq_newuserdata(v, sizeof(sym)); *p = sym; return 1; }
static SQInteger _mod_fseek(HSQUIRRELVM v) { SQUserPointer pf = 0; SQInteger seek; SQInteger pos; sq_getuserpointer(v, 2, &pf); sq_getinteger(v, 3, &seek); sq_getinteger(v, 4, &pos); if(pf) { fseek((FILE*)pf,seek,pos); return 1; } return 0; }
int SquirrelScriptContext::SquirrelFunctionCallback(HSQUIRRELVM vm) { MultiScriptAssert( sq_gettype(vm, -1) == OT_USERPOINTER ); void* userPtr = NULL; sq_getuserpointer(vm, -1, &userPtr); sq_pop(vm, 1); SquirrelFunctionInfo* info = (SquirrelFunctionInfo*) userPtr; SquirrelScriptStack stack(info->m_context, false); const bool result = info->m_desc->m_function(&stack); MultiScriptAssert( result ); return stack.m_numPushed; }
// Get file from Squirrel stack static FILE* GetFile () { FILE* file; sq_getuserpointer(sqvm, 2, (SQUserPointer*)&file); if (file) { if (file == stdout || file == stderr) return file; for (unsigned i = 0; i < MAX_OPENED_FILES; ++i) { if (file == files[i]) return file; } } return NULL; }
// fclose(handle file) // Close file static SQInteger FClose (HSQUIRRELVM) { FILE* file; sq_getuserpointer(sqvm, 2, (SQUserPointer*)&file); if (file) { for (unsigned i = 0; i < MAX_OPENED_FILES; ++i) { if (file != files[i]) continue; fclose(file); files[i] = NULL; --numFiles; _RPT2(_CRT_WARN, "--- Closed file #%d. %d file(s) are still opened.\n", i, numFiles); break; } } return 0; }
/* * get instance member value as user pointer */ bool getInstanceMemberAsUserPointer(HSQUIRRELVM v, int idx, const char *cname, const char *name, SQUserPointer* value) { if (sq_gettype(v, idx) == OT_NULL) return false; sq_pushstring(v, cname, -1); if (!SQ_SUCCEEDED(sq_get(v, idx))) { sq_pop(v, 1); return false; } sq_pushstring(v, name, -1); if (!SQ_SUCCEEDED(sq_get(v, -2))) { sq_pop(v, 2); return false; } if (sq_gettype(v, -1) != OT_USERPOINTER) { sq_pop(v, 2); return false; } sq_getuserpointer(v, -1, value); sq_pop(v, 2); return true; }
static ffi_type *get_ffi_type(HSQUIRRELVM v, int idx) { int type = sq_gettype(v, idx); void *p; const SQChar *s; ffi_type *t; switch (type) { case OT_USERPOINTER: sq_getuserpointer(v, idx, &p); return (ffi_type*)p; case OT_STRING: sq_getstring(v, idx, &s); t = char2ffi_type(*s); if (t) return t; default: sq_throwerror(v, "Type spec must be string or ffi_type"); return NULL; } }
static SQInteger _mod_fread(HSQUIRRELVM v) { SQUserPointer pf = 0; SQInteger bytes; sq_getuserpointer(v, 2, &pf); sq_getinteger(v, 3, &bytes); if(pf) { char* pc = new char[bytes+1]; if(pc) { bytes = fread(pc, 1, bytes, (FILE*)pf); if(bytes>0) { pc[bytes] = 0; sq_pushstring(v, pc, bytes); delete[] pc; return 1; } sq_pushstring(v, "", 0); delete[] pc; } } return 0; }
// BOOL VwKillTimer(SQInteger uIDEvent) SQInteger VwKillTimer(HSQUIRRELVM v) { SQUserPointer uIDEvent = 0; SQInteger nargs = sq_gettop(v); if (!v || 1 + 1 != nargs) {goto _Exit_;} if (OT_USERPOINTER != sq_gettype(v, 2)) {goto _Exit_;} sq_getuserpointer(v, 2, &uIDEvent); CScriptMgr* pMgr = (CScriptMgr*)sq_getforeignptr(v); if (!pMgr) {goto _Exit_;} CPaintManagerUI* pPM = pMgr->GetManager(); if (!pPM) {goto _Exit_;} ::KillTimer(pPM->GetPaintWindow(), (UINT_PTR)uIDEvent); delete (SetTimerParam*)uIDEvent; _Exit_: sq_pushbool(v, TRUE); return 1; }
static SQInteger _mod_fgets(HSQUIRRELVM v) { SQUserPointer pf = 0; char* bytes; sq_getuserpointer(v, 2, &pf); if(pf) { if(feof((FILE*)pf)) { sq_pushstring(v, "", 0); return 0; } char local[256] = {0}; bytes = fgets(local, 255, (FILE*)pf); if(bytes) { const char* pl = str_deleol(local); size_t len = strlen(pl); sq_pushstring(v, pl, len); return len; } sq_pushstring(v, "", 0); } return 0; }
int SquirrelScriptContext::SquirrelClassDestructorCallback(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 user supplied destructor scriptObject->m_lockedByScript = true; classInfo->m_desc->m_destructor(scriptObject); scriptObject->m_lockedByScript = false; scriptObject->m_objectPtr = NULL; return 0; }
int Xml_eval(HSQUIRRELVM v) { SQ_FUNC_VARS_NO_TOP(v); SQChar* str = 0; size_t str_size=0; if(sq_gettype(v,2) == OT_USERPOINTER) sq_getuserpointer(v, 2, &str); else { SQ_GET_STRING(v, 2, sTmp); str = (SQChar*)sq_malloc(sTmp_size+(sizeof(SQChar))); memcpy(str, sTmp, sTmp_size); str[sTmp_size]=0; str_size = sTmp_size; } Tokenizer* tok = Tokenizer_new(str, str_size ? str_size : scstrlen(str)); sq_settop(v,0); const SQChar* token=0; int firstStatement = 1; while((token=Tokenizer_next(tok))!=0) if(token[0]==OPN) { // new tag found if(sq_gettop(v)) { int newIndex=sq_size(v,-1)+1; sq_pushinteger(v,newIndex); sq_newtable(v); sq_set(v, -3); sq_pushinteger(v,newIndex); sq_get(v,-2); } else { if (firstStatement) { sq_newtable(v); firstStatement = 0; } else return lua_gettop(L); } // set metatable: sq_newtable(v); sq_pushliteral(v, _SC("__index")); sq_getglobal(v, "xml"); lua_settable(v, -3); sq_pushliteral(v, _SC("__tostring")); // set __tostring metamethod lua_getglobal(L, "xml"); lua_pushliteral(L,"str"); lua_gettable(v, -2); sq_remove(v, -2); sq_set(v, -3); lua_setmetatable(L, -2); // parse tag and content: sq_pushinteger(v,0); // use index 0 for storing the tag sq_pushstring(v, Tokenizer_next(tok), -1); sq_set(v, -3); while(((token = Tokenizer_next(tok))!=0)&&(token[0]!=CLS)&&(token[0]!=ESC)) { // parse tag header size_t sepPos=find(token, "=", 0); if(token[sepPos]) { // regular attribute const SQChar* aVal =token+sepPos+2; sq_pushstring(v, token, sepPos); size_t lenVal = strlen(aVal)-1; if(!lenVal) Xml_pushDecode(v, _SC(""), 0); else Xml_pushDecode(v, aVal, lenVal); sq_set(v, -3); } } if(!token||(token[0]==ESC)) { if(sq_gettop(v)>1) sq_settop(v,-2); // this tag has no content, only attributes else break; } } else if(token[0]==ESC) { // previous tag is over if(sq_gettop(v)>1) sq_settop(v,-2); // pop current table else break; } else { // read elements sq_pushinteger(v,sq_size(v,-1)+1); Xml_pushDecode(v, token, 0); sq_rawset(v, -3); } Tokenizer_delete(tok); sq_free(str); return sq_gettop(v); }
template <> inline void *GetParam(ForceType<void *> , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }
/* ** Copies values from State src to State dst. */ static SQRESULT copy_values_between_vms (HSQUIRRELVM dst, HSQUIRRELVM src, int argc, int argIdx) { SQRESULT _rc_; sq_reservestack(dst, argc + 20); argc += argIdx; //we will work with argc args starting at argIdx for (; argIdx < argc; argIdx++) { switch (sq_gettype(src, argIdx)) { case OT_INTEGER: SQ_GET_INTEGER(src, argIdx, vint); sq_pushinteger(dst, vint); break; case OT_FLOAT: SQ_GET_FLOAT(src, argIdx, vfloat); sq_pushfloat (dst, vfloat); break; case OT_BOOL: SQ_GET_BOOL(src, argIdx, vbool); sq_pushbool (dst, vbool); break; case OT_STRING: { SQ_GET_STRING(src, argIdx, vstr) sq_pushstring (dst, vstr, vstr_size); } break; case OT_ARRAY: { SQInteger size = sq_getsize(src, argIdx); sq_newarray(dst, size); for(SQInteger i=0; i<size; ++i) { sq_pushinteger(src, i); sq_get(src, -2); sq_pushinteger(dst, i); if(copy_values_between_vms(dst, src, 1, sq_gettop(src)) != SQ_OK) return SQ_ERROR; sq_poptop(src); sq_set(dst, -3); } } break; case OT_TABLE: { sq_newtable(dst); sq_pushnull(src); while(sq_next(src, -2) == SQ_OK) { SQInteger src_top = sq_gettop(src); if(copy_values_between_vms(dst, src, 1, src_top-1) != SQ_OK || copy_values_between_vms(dst, src, 1, src_top) != SQ_OK) return SQ_ERROR; sq_newslot(dst, -3, SQFalse); sq_pop(src, 2); } sq_pop(src,1); } break; case OT_USERPOINTER: { SQUserPointer ptr; sq_getuserpointer(src, argIdx, &ptr); sq_pushuserpointer(dst, ptr); } break; case OT_NULL: sq_pushnull(dst); break; default: return SQ_ERROR; } } return SQ_OK; }
void* CSquirrelVM::GetUserData(int idx) { SQUserPointer p; sq_getuserpointer(m_pVM, -1, &p); return (void*)p; }